Robots con Visión por Computadora: Detección y Seguimiento de Objetos con OpenCV y Python

Introducción a la Visión por Computadora en Robótica 🤖👁️

La visión por computadora es un campo fascinante que permite a las máquinas 'ver' e interpretar el mundo visual que las rodea. En robótica, esta capacidad transforma a los robots de meras herramientas programadas a entidades capaces de percibir, analizar y reaccionar a su entorno de manera autónoma. Desde la navegación y la manipulación de objetos hasta la interacción humano-robot y la inspección de calidad, la visión por computadora es un componente fundamental para la robótica moderna.

En este tutorial, nos enfocaremos en una aplicación práctica y muy útil: la detección y el seguimiento de objetos. Utilizaremos la popular biblioteca OpenCV (Open Source Computer Vision Library) junto con Python para desarrollar soluciones que permitan a un robot identificar y seguir un objeto específico. Esto abre un sinfín de posibilidades, como robots que recogen objetos, sistemas de seguridad que detectan intrusos o incluso asistentes robóticos que interactúan con su entorno basado en lo que ven.

¿Por qué OpenCV y Python? ✨

• OpenCV: Es la biblioteca de visión por computadora más grande del mundo. Ofrece miles de algoritmos optimizados para procesamiento de imágenes y videos, detección de objetos, aprendizaje automático y mucho más. Es de código abierto, multiplataforma y tiene una enorme comunidad de soporte.
• Python: Es un lenguaje de programación versátil, fácil de aprender y muy potente. Su sintaxis limpia y su vasto ecosistema de bibliotecas (incluyendo NumPy para operaciones numéricas eficientes, que es fundamental para OpenCV) lo hacen la elección perfecta para prototipado rápido y desarrollo de sistemas de visión.

🛠️ Herramientas y Materiales Necesarios

Para seguir este tutorial, necesitarás algunos componentes de hardware y software.

Hardware:

• Computadora o SBC (Single Board Computer): Un PC de escritorio, laptop o una Raspberry Pi 4 (o superior) será suficiente. Asegúrate de que tenga suficiente potencia para procesar video en tiempo real.
• Cámara: Una webcam USB estándar o el módulo de cámara de Raspberry Pi. La resolución mínima recomendada es 720p.
• Opcional - Plataforma Robótica: Si deseas integrar esto en un robot físico, necesitarás un robot móvil (por ejemplo, uno diferencial) con un controlador capaz de recibir comandos (como un Arduino o ESP32) y servomotores o motores DC. Este tutorial se centrará en la parte de visión, pero se darán pautas para la integración.

Software:

• Sistema Operativo: Windows, macOS o Linux (Raspberry Pi OS).
• Python 3.x: Asegúrate de tener Python instalado.
• Pip: El gestor de paquetes de Python.
• OpenCV para Python: La biblioteca principal de visión por computadora.
• NumPy: Para manejo eficiente de matrices numéricas.

Instalación del Entorno 🐍

Abriremos una terminal o línea de comandos e instalaremos las bibliotecas necesarias. Es una buena práctica usar un entorno virtual para proyectos de Python.

1. Crear un entorno virtual (opcional pero recomendado):

python3 -m venv vision_env
source vision_env/bin/activate  # En Linux/macOS
# vision_env\Scripts\activate   # En Windows

2. Instalar OpenCV y NumPy:

pip install opencv-python numpy

<div class="callout tip">💡 <strong>Consejo:</strong> Si experimentas problemas de rendimiento en Raspberry Pi, puedes probar `pip install opencv-contrib-python` para tener acceso a funciones adicionales, pero es un paquete más pesado. Para este tutorial, `opencv-python` es suficiente.</div>

Conceptos Fundamentales de Visión por Computadora 📖

Antes de sumergirnos en el código, es importante entender algunos conceptos básicos.

1. Imágenes Digitales

Una imagen digital es esencialmente una cuadrícula de píxeles. Cada píxel tiene un valor que representa su color o intensidad. En OpenCV, las imágenes se tratan como matrices NumPy.

• Imágenes en escala de grises: Cada píxel tiene un valor de 0 (negro) a 255 (blanco), representando la intensidad.
• Imágenes a color (RGB/BGR): Cada píxel tiene 3 valores (canales) que representan la intensidad de rojo, verde y azul. OpenCV, por defecto, usa el orden BGR (Azul, Verde, Rojo).

2. Procesamiento Básico de Imágenes

• Captura de video: Leer fotogramas (frames) de una cámara o archivo de video.
• Conversión de color: Cambiar el espacio de color de una imagen, por ejemplo, de BGR a HSV (Hue, Saturation, Value), que es muy útil para la detección de color.
• Umbralización (Thresholding): Convertir una imagen a escala de grises en una imagen binaria (blanco y negro) aplicando un umbral. Esto es clave para aislar objetos.
• Operaciones morfológicas: Transformaciones como la erosión y la dilatación, que ayudan a limpiar el ruido de las imágenes binarias y a refinar las formas de los objetos.

3. Detección de Contornos

Un contorno es una curva que une todos los puntos continuos (a lo largo del límite) que tienen el mismo color o intensidad. Los contornos son esenciales para la detección y descripción de formas en una imagen.

4. Seguimiento de Objetos

Una vez que se detecta un objeto, el seguimiento implica localizarlo en fotogramas sucesivos de un video. Esto puede hacerse de varias maneras, pero una común es encontrar el contorno más grande que se asemeja al objeto que buscamos o usar algoritmos de seguimiento más sofisticados como CAMShift o MeanShift (fuera del alcance de este tutorial, pero se mencionan para referencia).

🎯 Detección de Objetos por Color con OpenCV

Comenzaremos con la técnica más sencilla pero efectiva para la detección de objetos: el filtrado por color. Esto es ideal para entornos controlados donde el objeto de interés tiene un color distintivo.

Paso 1: Configuración de la Cámara y Captura de Video

import cv2
import numpy as np

def main():
    cap = cv2.VideoCapture(0) # 0 para la webcam predeterminada

    if not cap.isOpened():
        print("Error: No se puede abrir la cámara.")
        return

    while True:
        ret, frame = cap.read()
        if not ret:
            print("Error: No se pudo leer el fotograma.")
            break

        cv2.imshow('Frame Original', frame)

        if cv2.waitKey(1) & 0xFF == ord('q'): # Presiona 'q' para salir
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

Este script básico inicializa la cámara, captura fotogramas continuamente y los muestra en una ventana. Presiona q para salir.

Paso 2: Convertir a Espacio de Color HSV

El espacio de color HSV (Hue, Saturation, Value) es mucho mejor que BGR para la detección basada en color porque separa la información de color (Hue) de la intensidad de la luz (Value) y la pureza del color (Saturation). Esto hace que la detección sea menos sensible a las variaciones de iluminación.

import cv2
import numpy as np

def main():
    cap = cv2.VideoCapture(0)

    if not cap.isOpened():
        print("Error: No se puede abrir la cámara.")
        return

    while True:
        ret, frame = cap.read()
        if not ret:
            print("Error: No se pudo leer el fotograma.")
            break

        # Convertir el fotograma de BGR a HSV
        hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

        cv2.imshow('Frame Original', frame)
        cv2.imshow('Frame HSV', hsv_frame)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

Paso 3: Definir Rangos de Color y Crear una Máscara

Necesitamos definir los límites inferior y superior de los valores HSV para el color que queremos detectar. Por ejemplo, si queremos detectar un objeto rojo, buscaremos los rangos de rojo en HSV. Los objetos rojos pueden tener dos rangos de Hue (cerca de 0 y cerca de 179).

Para encontrar los rangos exactos de un color, puedes usar una herramienta como un selector de color HSV en línea o, para una mayor precisión, una pequeña interfaz gráfica de usuario (GUI) con trackbars de OpenCV, que te permite ajustar los valores en tiempo real. Para este tutorial, usaremos rangos predefinidos para un color azul, que son bastante comunes.

import cv2
import numpy as np

def main():
    cap = cv2.VideoCapture(0)

    if not cap.isOpened():
        print("Error: No se puede abrir la cámara.")
        return

    # Definir el rango de color azul en HSV
    # Estos valores pueden necesitar ajustes dependiendo de la iluminación y el tono exacto del objeto.
    lower_blue = np.array([100, 50, 50])   # Tono, Saturación, Valor mínimos
    upper_blue = np.array([130, 255, 255]) # Tono, Saturación, Valor máximos

    while True:
        ret, frame = cap.read()
        if not ret:
            print("Error: No se pudo leer el fotograma.")
            break

        hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

        # Crear una máscara para el color azul
        mask = cv2.inRange(hsv_frame, lower_blue, upper_blue)

        # Aplicar la máscara al fotograma original para ver solo el objeto detectado
        res = cv2.bitwise_and(frame, frame, mask=mask)

        cv2.imshow('Frame Original', frame)
        cv2.imshow('Mascara', mask)
        cv2.imshow('Resultado', res)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

Ahora deberías ver tres ventanas: el fotograma original, la máscara (donde el objeto azul es blanco y todo lo demás es negro) y el resultado (el fotograma original con solo el objeto azul visible).

Paso 4: Limpiar la Máscara con Operaciones Morfológicas

La máscara a menudo tendrá ruido (pequeños puntos blancos o agujeros). Podemos limpiarla usando operaciones morfológicas como la erosión y la dilatación.

• Erosión: Reduce el tamaño de los objetos blancos, eliminando pequeños puntos de ruido.
• Dilatación: Aumenta el tamaño de los objetos blancos, rellenando pequeños agujeros.

import cv2
import numpy as np

def main():
    cap = cv2.VideoCapture(0)
    if not cap.isOpened():
        print("Error: No se puede abrir la cámara.")
        return

    lower_blue = np.array([100, 50, 50])
    upper_blue = np.array([130, 255, 255])

    while True:
        ret, frame = cap.read()
        if not ret:
            print("Error: No se pudo leer el fotograma.")
            break

        hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        mask = cv2.inRange(hsv_frame, lower_blue, upper_blue)

        # Aplicar operaciones morfológicas para limpiar la máscara
        kernel = np.ones((5, 5), np.uint8)
        mask = cv2.erode(mask, kernel, iterations=1)
        mask = cv2.dilate(mask, kernel, iterations=1)

        res = cv2.bitwise_and(frame, frame, mask=mask)

        cv2.imshow('Frame Original', frame)
        cv2.imshow('Mascara Limpia', mask)
        cv2.imshow('Resultado Limpio', res)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

🔍 Detección y Seguimiento de Contornos

Una vez que tenemos una máscara binaria limpia, el siguiente paso es encontrar los contornos de los objetos blancos. Esto nos permitirá obtener propiedades como el área, el centroide o las dimensiones del objeto detectado.

Paso 5: Encontrar y Dibujar Contornos

import cv2
import numpy as np

def main():
    cap = cv2.VideoCapture(0)
    if not cap.isOpened():
        print("Error: No se puede abrir la cámara.")
        return

    lower_blue = np.array([100, 50, 50])
    upper_blue = np.array([130, 255, 255])

    while True:
        ret, frame = cap.read()
        if not ret:
            print("Error: No se pudo leer el fotograma.")
            break

        hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        mask = cv2.inRange(hsv_frame, lower_blue, upper_blue)

        kernel = np.ones((5, 5), np.uint8)
        mask = cv2.erode(mask, kernel, iterations=1)
        mask = cv2.dilate(mask, kernel, iterations=1)

        # Encontrar contornos en la máscara
        # cv2.findContours devuelve una tupla de (contornos, jerarquía) en OpenCV 3.x y 4.x
        # o solo contornos si se usa en versiones anteriores.
        # Para asegurar la compatibilidad, tomamos el segundo elemento si la tupla tiene 2 o 3 elementos.
        contours, _ = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        # Dibujar los contornos encontrados en el fotograma original
        output_frame = frame.copy()
        cv2.drawContours(output_frame, contours, -1, (0, 255, 0), 2) # Color verde, grosor 2

        cv2.imshow('Frame con Contornos', output_frame)
        cv2.imshow('Mascara Limpia', mask)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

Paso 6: Filtrar y Centrar el Objeto Principal

Normalmente, tendremos varios contornos, algunos de ellos pequeños debido a ruido residual. Queremos identificar el contorno más grande, que probablemente corresponda a nuestro objeto de interés. Una vez identificado, podemos calcular su centroide y dibujar un recuadro delimitador.

El centroide es el punto central del objeto, crucial para el seguimiento del robot.

import cv2
import numpy as np

def main():
    cap = cv2.VideoCapture(0)
    if not cap.isOpened():
        print("Error: No se puede abrir la cámara.")
        return

    lower_blue = np.array([100, 50, 50])
    upper_blue = np.array([130, 255, 255])

    while True:
        ret, frame = cap.read()
        if not ret:
            print("Error: No se pudo leer el fotograma.")
            break

        hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        mask = cv2.inRange(hsv_frame, lower_blue, upper_blue)

        kernel = np.ones((5, 5), np.uint8)
        mask = cv2.erode(mask, kernel, iterations=1)
        mask = cv2.dilate(mask, kernel, iterations=1)

        contours, _ = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        output_frame = frame.copy()
        center_x = 0
        center_y = 0

        if len(contours) > 0:
            # Encontrar el contorno más grande
            largest_contour = max(contours, key=cv2.contourArea)

            # Solo procesar si el área del contorno es suficientemente grande para evitar ruido
            if cv2.contourArea(largest_contour) > 500: # Ajusta este valor según el tamaño de tu objeto
                # Calcular el centroide (momento) del contorno
                M = cv2.moments(largest_contour)
                if M["m00"] != 0: # Evitar división por cero
                    center_x = int(M["m10"] / M["m00"])
                    center_y = int(M["m01"] / M["m00"])

                    # Dibujar un círculo en el centroide
                    cv2.circle(output_frame, (center_x, center_y), 7, (255, 0, 0), -1)

                    # Dibujar un recuadro delimitador alrededor del objeto
                    x, y, w, h = cv2.boundingRect(largest_contour)
                    cv2.rectangle(output_frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
                    cv2.putText(output_frame, f"Objeto detectado: ({center_x}, {center_y})", (x, y - 10), 
                                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
            else:
                cv2.putText(output_frame, "Objeto demasiado pequeño o no detectado", (10, 30), 
                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
        else:
            cv2.putText(output_frame, "No se detectaron objetos", (10, 30), 
                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)

        cv2.imshow('Seguimiento de Objeto', output_frame)
        cv2.imshow('Mascara', mask)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

Este código ahora detecta el objeto azul más grande, dibuja un círculo en su centro y un recuadro delimitador a su alrededor. También muestra las coordenadas del centroide. Esta información (las coordenadas center_x y center_y) es la clave para la interacción robótica.

⚙️ Integración con un Robot (Conceptos)

Ahora que tenemos la detección y el seguimiento visual, ¿cómo lo conectamos a un robot físico? La idea principal es usar las coordenadas del centroide del objeto para guiar los movimientos del robot.

Estrategia de Control Simple:

Imaginemos que nuestro robot necesita mantener el objeto detectado en el centro horizontal del campo de visión de la cámara. La cámara suele estar montada en el robot.

1. Obtener las dimensiones del frame: frame_width = frame.shape[1]. El centro del frame será frame_width / 2.

2. Calcular el error: error_x = center_x - (frame_width / 2). Si error_x es positivo, el objeto está a la derecha del centro. Si es negativo, a la izquierda.

3. Enviar comandos al robot:

   • Si error_x es positivo (objeto a la derecha), el robot debe girar a la derecha.
   • Si error_x es negativo (objeto a la izquierda), el robot debe girar a la izquierda.
   • Si error_x está cerca de cero (dentro de un umbral), el robot está centrado.

   Podemos añadir un control de distancia usando el área del objeto o la altura del recuadro delimitador. Si el objeto es demasiado pequeño (lejos), el robot avanza. Si es demasiado grande (cerca), retrocede.

Ejemplo de Lógica de Control (Pseudocódigo):

# ... dentro del bucle while True, después de calcular center_x ...

    frame_width = frame.shape[1]
    center_frame_x = frame_width / 2

    if len(contours) > 0 and cv2.contourArea(largest_contour) > 500:
        # ... código para calcular center_x y center_y ...

        # Lógica de seguimiento
        tolerancia = 20 # Píxeles de margen para considerar 'centrado'

        if center_x < center_frame_x - tolerancia:
            # print("Girar a la izquierda")
            # Enviar comando al microcontrolador para girar a la izquierda
            pass # Reemplazar con lógica de comunicación serial/Wi-Fi
        elif center_x > center_frame_x + tolerancia:
            # print("Girar a la derecha")
            # Enviar comando al microcontrolador para girar a la derecha
            pass # Reemplazar con lógica de comunicación serial/Wi-Fi
        else:
            # print("Objeto centrado")
            # Puedes implementar lógica de avance/retroceso aquí
            # Por ejemplo, si el área es muy pequeña, avanzar
            area = cv2.contourArea(largest_contour)
            if area < 10000: # Si el objeto está lejos
                # print("Avanzar")
                pass # Enviar comando para avanzar
            elif area > 30000: # Si el objeto está muy cerca
                # print("Retroceder")
                pass # Enviar comando para retroceder
            else:
                # print("Detener")
                pass # Enviar comando para detener
    else:
        # print("Objeto no detectado, detener o buscar")
        pass # Enviar comando para detener o iniciar un modo de búsqueda

# ... el resto del código ...

Opciones de Comunicación con el Robot:

• Comunicación Serial (UART): Ideal para microcontroladores como Arduino o ESP32 conectados por USB. Python puede usar la biblioteca pyserial.
• Comunicación Wi-Fi (Sockets): Si el robot tiene una placa Wi-Fi (como un ESP32 o Raspberry Pi), puedes usar sockets TCP/IP o UDP para enviar comandos. Es más flexible para robots inalámbricos.
• ROS (Robot Operating System): Para proyectos de robótica más complejos, ROS proporciona un marco robusto para la comunicación entre diferentes nodos (visión, control de motores, navegación, etc.).

import serial
import time

# ... (código anterior para detección de objetos)

# Inicializar puerto serial (ajusta 'COM3' o '/dev/ttyUSB0' y baudrate)
# try:
#     ser = serial.Serial('COM3', 9600, timeout=1)
#     time.sleep(2) # Espera a que la conexión serial se establezca
#     print("Conexión serial establecida.")
# except serial.SerialException as e:
#     print(f"Error al abrir el puerto serial: {e}")
#     ser = None

# ... dentro del bucle while True ...
# Reemplazar pass con:
# if ser:
#     if center_x < center_frame_x - tolerancia:
#         ser.write(b'L') # 'L' para girar a la izquierda
#     elif center_x > center_frame_x + tolerancia:
#         ser.write(b'R') # 'R' para girar a la derecha
#     else:
#         ser.write(b'S') # 'S' para detener (o 'F' para avanzar, 'B' para retroceder, etc.)
# else:
#     print("Serial no conectado, no se pueden enviar comandos.")

# ... al final del main, antes de cap.release() ...
# if ser: ser.close()

// Código Arduino simplificado
char incomingByte;

void setup() {
  Serial.begin(9600);
  // Configurar pines de motor
}

void loop() {
  if (Serial.available() > 0) {
    incomingByte = Serial.read();
    if (incomingByte == 'L') {
      // Controlar motores para girar a la izquierda
      // Serial.println("Girar Izquierda");
    } else if (incomingByte == 'R') {
      // Controlar motores para girar a la derecha
      // Serial.println("Girar Derecha");
    } else if (incomingByte == 'S') {
      // Detener motores
      // Serial.println("Detener");
    } 
    // Añadir lógica para 'F' (avanzar) y 'B' (retroceder) si es necesario
  }
}

Conclusión y Próximos Pasos 🚀

¡Felicidades! Has completado un tutorial que te introduce en la detección y seguimiento de objetos mediante visión por computadora con OpenCV y Python. Has aprendido a configurar tu entorno, comprender los conceptos básicos de imágenes, filtrar por color, detectar contornos y establecer la base para la integración robótica. Esta es una habilidad fundamental que te abrirá muchas puertas en el emocionante mundo de la robótica y la inteligencia artificial.

Ideas para Expandir tu Proyecto:

• Detección de Múltiples Colores: Modifica el código para detectar y seguir varios objetos de diferentes colores simultáneamente.
• Detección de Formas: Además del color, puedes identificar objetos basándote en su forma (círculos, cuadrados) utilizando cv2.approxPolyDP o cv2.matchShapes.
• Algoritmos de Seguimiento más Avanzados: Investiga algoritmos como MeanShift, CAMShift o los trackers de objetos integrados en OpenCV (KCF, CSRT, etc.) para un seguimiento más robusto en entornos cambiantes.
• Reconocimiento de Rostros o Marcadores AR: Utiliza detectores pre-entrenados de OpenCV (Haar Cascades, detectores de rostros Dlib) o bibliotecas como ArUco para añadir capacidades de reconocimiento más complejas.
• Robots con Pan-Tilt: Monta la cámara en una plataforma pan-tilt (movimiento horizontal y vertical) controlada por servomotores, y usa las coordenadas center_x y center_y para apuntar la cámara al objeto.
• Persistencia y Machine Learning: Para una detección más robusta en entornos complejos, podrías explorar el uso de modelos de aprendizaje automático (como redes neuronales convolucionales) para la detección de objetos (ej. YOLO, SSD).

La robótica con visión por computadora es un campo en constante evolución, y las posibilidades son infinitas. Sigue experimentando, construyendo y aprendiendo. ¡El futuro de los robots inteligentes está en tus manos!