Conecta tu cámara con Python: detección de rostros y objetos en tiempo real con OpenCV y YOLO

Problema real: quieres probar inteligencia artificial con tu cámara, pero no sabes por dónde empezar

La visión por computadora suena compleja, pero puedes empezar con algo muy concreto: usar la cámara de tu laptop para detectar rostros y objetos en tiempo real.

Este tipo de proyecto sirve para aprender la base de aplicaciones como:

• Cámaras inteligentes.
• Control de acceso.
• Conteo de personas.
• Seguridad básica.
• Detección de objetos.
• Automatización con video.
• Prototipos de inteligencia artificial.
• Sistemas de asistencia visual.
• Monitoreo de espacios.
• Proyectos educativos o universitarios.

La idea no es crear un sistema perfecto de seguridad, sino construir un prototipo funcional que puedas ejecutar en tu computadora.

En esta guía aprenderás tres cosas:

1. Abrir tu cámara con Python.
2. Detectar rostros con OpenCV.
3. Detectar objetos con YOLO en tiempo real.

Qué vas a construir

Al finalizar tendrás tres scripts:

01_webcam_basica.py
02_detector_rostros.py
03_detector_objetos_yolo.py

Cada uno hará algo distinto:

Herramientas que usaremos

OpenCV documenta el uso de clasificadores en cascada para detección de rostros, y Ultralytics YOLO permite ejecutar predicciones sobre imágenes, videos y transmisiones en vivo, incluyendo cámaras.

Requisitos previos

Necesitas:

• Python 3.10 o superior.
• Una cámara web integrada o externa.
• Windows, Linux o macOS.
• Conexión a internet para instalar paquetes y descargar el modelo inicial.
• Conocimientos básicos de terminal.

Verifica Python:

python --version

o:

py --version

Paso 1: crea la carpeta del proyecto

En Windows PowerShell:

mkdir vision-python-camara
cd vision-python-camara

En Linux o macOS:

mkdir vision-python-camara
cd vision-python-camara

Paso 2: crea un entorno virtual

En Windows:

py -m venv .venv
.\.venv\Scripts\activate

En Linux o macOS:

python3 -m venv .venv
source .venv/bin/activate

Cuando el entorno esté activo, deberías ver algo como:

(.venv)

Paso 3: instala las librerías necesarias

Instala OpenCV y Ultralytics:

pip install opencv-python ultralytics

Verifica instalación:

python -c "import cv2; print(cv2.__version__)"

También:

python -c "from ultralytics import YOLO; print('YOLO instalado')"

Paso 4: prueba que Python pueda abrir tu cámara

Crea el archivo:

01_webcam_basica.py

Código:

import cv2

camara = cv2.VideoCapture(0)

if not camara.isOpened():
    print("No se pudo abrir la cámara.")
    exit()

while True:
    ret, frame = camara.read()

    if not ret:
        print("No se pudo leer el frame de la cámara.")
        break

    cv2.imshow("Webcam básica - presiona Q para salir", frame)

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

camara.release()
cv2.destroyAllWindows()

Ejecuta:

python 01_webcam_basica.py

Si aparece la ventana con tu cámara, todo está correcto.

Para salir, presiona:

Q

Paso 5: si tienes varias cámaras

OpenCV usa índices numéricos para acceder a cámaras.

Prueba cambiar:

cv2.VideoCapture(0)

por:

cv2.VideoCapture(1)

o:

cv2.VideoCapture(2)

Esto es común si tienes:

• Webcam integrada.
• Cámara USB.
• Capturadora HDMI.
• Cámara virtual.
• Celular usado como webcam.

Paso 6: detector de rostros con OpenCV

OpenCV incluye clasificadores Haar Cascade que permiten detectar rostros de forma sencilla.

Crea el archivo:

02_detector_rostros.py

Código:

import cv2

camara = cv2.VideoCapture(0)

if not camara.isOpened():
    print("No se pudo abrir la cámara.")
    exit()

ruta_cascade = cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
detector_rostros = cv2.CascadeClassifier(ruta_cascade)

if detector_rostros.empty():
    print("No se pudo cargar el clasificador Haar Cascade.")
    exit()

while True:
    ret, frame = camara.read()

    if not ret:
        print("No se pudo leer el frame.")
        break

    gris = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    rostros = detector_rostros.detectMultiScale(
        gris,
        scaleFactor=1.1,
        minNeighbors=5,
        minSize=(60, 60)
    )

    for (x, y, w, h) in rostros:
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
        cv2.putText(
            frame,
            "Rostro",
            (x, y - 10),
            cv2.FONT_HERSHEY_SIMPLEX,
            0.7,
            (0, 255, 0),
            2
        )

    cv2.imshow("Detector de rostros - presiona Q para salir", frame)

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

camara.release()
cv2.destroyAllWindows()

Ejecuta:

python 02_detector_rostros.py

Deberías ver un rectángulo verde cuando tu rostro aparezca frente a la cámara.

Cómo funciona este detector de rostros

El flujo es simple:

1. Se abre la cámara.
2. Se lee cada frame.
3. Se convierte la imagen a escala de grises.
4. Se aplica el clasificador Haar Cascade.
5. Se dibuja un rectángulo sobre cada rostro detectado.
6. Se muestra el resultado en pantalla.

Este método es ideal para aprender, pero no es el más moderno ni el más preciso.

Limitaciones del detector Haar Cascade

Puede fallar si:

• Hay poca luz.
• El rostro está de lado.
• Hay gafas, mascarilla o sombras fuertes.
• La cámara tiene baja calidad.
• La persona está muy lejos.
• Hay movimiento rápido.
• Hay varios rostros parcialmente cubiertos.

Para proyectos serios, conviene usar modelos más modernos basados en deep learning.

Paso 7: detección de objetos con YOLO

Ahora haremos algo más interesante: detectar objetos en tiempo real.

YOLO puede identificar objetos comunes como:

• Persona.
• Celular.
• Laptop.
• Taza.
• Silla.
• Botella.
• Mochila.
• Teclado.
• Mouse.
• Libro.
• Auto.
• Bicicleta.

Crea el archivo:

03_detector_objetos_yolo.py

Código:

from ultralytics import YOLO

# Modelo pequeño recomendado para empezar.
# La primera vez se descargará automáticamente.
modelo = YOLO("yolov8n.pt")

# source=0 usa la webcam principal.
# show=True muestra la ventana con detecciones.
# conf=0.5 filtra detecciones con confianza menor al 50%.
modelo.predict(source=0, show=True, conf=0.5)

Ejecuta:

python 03_detector_objetos_yolo.py

La primera vez puede demorar porque descargará el modelo.

Cuando se abra la cámara, prueba mostrar objetos como:

• Celular.
• Botella.
• Taza.
• Libro.
• Laptop.
• Mochila.

Paso 8: guardar resultados en video

Puedes guardar la salida con detecciones:

from ultralytics import YOLO

modelo = YOLO("yolov8n.pt")

modelo.predict(
    source=0,
    show=True,
    conf=0.5,
    save=True
)

Ultralytics guardará el resultado en una carpeta de ejecución, normalmente dentro de:

runs/detect/

Paso 9: usar otro modelo YOLO

El modelo yolov8n.pt es liviano y rápido. La n significa nano.

Opciones comunes:

Para empezar usa:

YOLO("yolov8n.pt")

Si tu PC es potente, prueba:

YOLO("yolov8s.pt")

Paso 10: mostrar solo objetos de interés

Puedes filtrar por confianza, pero también puedes procesar resultados manualmente.

Ejemplo básico:

from ultralytics import YOLO
import cv2

modelo = YOLO("yolov8n.pt")
camara = cv2.VideoCapture(0)

if not camara.isOpened():
    print("No se pudo abrir la cámara.")
    exit()

while True:
    ret, frame = camara.read()

    if not ret:
        break

    resultados = modelo(frame, conf=0.5, verbose=False)

    frame_anotado = resultados[0].plot()

    cv2.imshow("YOLO personalizado - presiona Q para salir", frame_anotado)

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

camara.release()
cv2.destroyAllWindows()

Este formato te da más control para integrar alertas o reglas.

Caso práctico 1: contador simple de personas

Puedes usar YOLO para contar cuántas personas aparecen en cámara.

Ejemplo:

from ultralytics import YOLO
import cv2

modelo = YOLO("yolov8n.pt")
camara = cv2.VideoCapture(0)

if not camara.isOpened():
    print("No se pudo abrir la cámara.")
    exit()

while True:
    ret, frame = camara.read()

    if not ret:
        break

    resultados = modelo(frame, conf=0.5, verbose=False)
    conteo_personas = 0

    for caja in resultados[0].boxes:
        clase_id = int(caja.cls[0])
        nombre = modelo.names[clase_id]

        if nombre == "person":
            conteo_personas += 1

    frame_anotado = resultados[0].plot()

    cv2.putText(
        frame_anotado,
        f"Personas: {conteo_personas}",
        (20, 40),
        cv2.FONT_HERSHEY_SIMPLEX,
        1,
        (0, 255, 0),
        2
    )

    cv2.imshow("Contador de personas - Q para salir", frame_anotado)

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

camara.release()
cv2.destroyAllWindows()

Uso posible:

• Control básico de aforo.
• Proyecto académico.
• Demo de visión artificial.
• Prueba de monitoreo local.

Caso práctico 2: detectar celulares frente a cámara

Puedes contar celulares detectados por YOLO.

from ultralytics import YOLO
import cv2

modelo = YOLO("yolov8n.pt")
camara = cv2.VideoCapture(0)

while True:
    ret, frame = camara.read()

    if not ret:
        break

    resultados = modelo(frame, conf=0.45, verbose=False)
    celulares = 0

    for caja in resultados[0].boxes:
        clase_id = int(caja.cls[0])
        nombre = modelo.names[clase_id]

        if nombre == "cell phone":
            celulares += 1

    frame_anotado = resultados[0].plot()

    cv2.putText(
        frame_anotado,
        f"Celulares detectados: {celulares}",
        (20, 40),
        cv2.FONT_HERSHEY_SIMPLEX,
        0.9,
        (255, 255, 0),
        2
    )

    cv2.imshow("Detector de celulares - Q para salir", frame_anotado)

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

camara.release()
cv2.destroyAllWindows()

Caso práctico 3: desenfocar rostros automáticamente

Esto es útil si quieres grabar una demo sin mostrar identidades.

import cv2

camara = cv2.VideoCapture(0)

ruta_cascade = cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
detector = cv2.CascadeClassifier(ruta_cascade)

while True:
    ret, frame = camara.read()

    if not ret:
        break

    gris = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    rostros = detector.detectMultiScale(
        gris,
        scaleFactor=1.1,
        minNeighbors=5,
        minSize=(60, 60)
    )

    for (x, y, w, h) in rostros:
        rostro = frame[y:y+h, x:x+w]
        rostro_blur = cv2.GaussianBlur(rostro, (99, 99), 30)
        frame[y:y+h, x:x+w] = rostro_blur

    cv2.imshow("Rostros desenfocados - Q para salir", frame)

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

camara.release()
cv2.destroyAllWindows()

Este enfoque es útil para privacidad en demostraciones.

Errores comunes y soluciones

Error 1: la cámara no abre

Mensaje posible:

No se pudo abrir la cámara.

Soluciones:

1. Cierra Zoom, Teams, Meet u otra app que use la cámara.
2. Prueba otro índice:

cv2.VideoCapture(1)

3. Revisa permisos de cámara en Windows:

Configuración > Privacidad y seguridad > Cámara

4. Si usas cámara USB, desconecta y conecta nuevamente.

Error 2: aparece una ventana negra

Causas posibles:

• Cámara ocupada.
• Driver fallando.
• Índice incorrecto.
• Permisos bloqueados.
• Cámara virtual sin señal.

Solución:

Prueba:

cv2.VideoCapture(1)

o reinicia la computadora.

Error 3: YOLO va muy lento

Soluciones:

1. Usa modelo nano:

YOLO("yolov8n.pt")

2. Baja la resolución de la cámara:

camara.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
camara.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

3. Cierra programas pesados.
4. Usa una PC con GPU si necesitas mayor velocidad.
5. Sube conf para filtrar detecciones débiles:

conf=0.6

Error 4: detecta objetos incorrectos

Esto puede pasar.

Soluciones:

• Mejora la iluminación.
• Acerca el objeto.
• Evita fondos saturados.
• Usa un modelo más preciso.
• Entrena un modelo personalizado si necesitas objetos específicos.

Error 5: detecta rostros donde no hay rostros

Los Haar Cascades pueden dar falsos positivos.

Soluciones:

• Aumenta minNeighbors.
• Usa minSize.
• Mejora iluminación.
• Usa un detector moderno si necesitas precisión.

Ejemplo:

rostros = detector.detectMultiScale(
    gris,
    scaleFactor=1.1,
    minNeighbors=7,
    minSize=(80, 80)
)

Buenas prácticas

1. Empieza con la webcam básica antes de usar IA.

2. Usa entornos virtuales para evitar conflictos.

3. No uses reconocimiento facial para identificar personas sin consentimiento.

4. Diferencia detección de rostro de reconocimiento de identidad.

5. Usa YOLO nano para pruebas iniciales.

6. Mejora iluminación antes de culpar al modelo.

7. No grabes ni publiques rostros sin autorización.

8. Evita usar estos scripts como sistema de seguridad real sin validación.

9. Guarda resultados solo si es necesario.

10. Documenta qué modelo usaste y con qué configuración.

Diferencia entre detectar rostro y reconocer identidad

Esto es importante:

Este post trabaja principalmente con:

Detección de rostros
Detección de objetos

No con identificación biométrica de personas.

Ideas de proyectos derivados

Puedes ampliar este proyecto hacia:

• Contador de personas.
• Detector de uso de celular.
• Cámara que desenfoca rostros.
• Registro de objetos detectados.
• Alerta si aparece una persona.
• Detector de casco o chaleco con modelo entrenado.
• Control de aforo.
• Monitor de escritorio.
• Cámara educativa para aprender IA.
• Prototipo para feria tecnológica.

Checklist final

Idea clave

Con Python, OpenCV y YOLO puedes convertir una cámara común en un prototipo de visión por computadora. Lo importante es avanzar por etapas: primero abrir la cámara, luego detectar rostros y finalmente detectar objetos. Así aprendes inteligencia artificial aplicada con un proyecto visual, útil y fácil de demostrar.