Este repositorio contiene la Práctica 4 donde se utilizan técnicas de procesamiento de video para la detección y seguimiento de vehículos y personas, aplicando reconocimiento de caracteres a las matrículas visibles. Para ello, hacemos uso de modelos YOLO para detectar objetos y OCRs para el reconocimiento de texto.
- Práctica 4. Reconocimiento de matrículas
- Índice
- Librerías utilizadas
- Autores
- Tarea
- Reentramiento del Modelo YOLO con Ultraytics
- Configuración Inicial y Parámetros
- Rutas de Video y Modelos
- Configuración de Salida
- Inicialización de Modelos
- Configuración de Real-ESRGAN
- Configuración de Entrada y Salida de Video
- Algoritmo Principal de Detección y Seguimiento
- Bucle de Fotogramas
- Procesamiento de Detecciones
- Detección y Reconocimiento de Matrículas
- Guardar Resultados y Liberación de Recursos
- Extra: Como instalar Real-ESRGAN
- Resultados
- Extra: Funcionalidades de Anonimización
- Referencias y bibliografía
Este proyecto fue desarrollado por:
El siguiente script configura y entrena un modelo YOLO usando un archivo .yaml
para definir las rutas de los datos y las clases:
from ultralytics import YOLO
# Ruta al archivo de configuración .yaml que especifica las rutas de los datos y las clases
yaml_path = "datasets/data.yaml"
# Ruta del modelo YOLO preentrenado que se usará como base
base_model = "yolo11n.pt" # Asegúrate de usar la versión correcta del modelo
# Configuración de hiperparámetros para el entrenamiento
img_size = 640 # Tamaño de las imágenes
batch_size = 16 # Ajusta según la memoria de tu GPU
epochs = 100 # Número de épocas
device = "cuda:0" # Especifica la GPU
def train_yolo():
model = YOLO(base_model)
model.train(
data=yaml_path,
imgsz=img_size,
batch=batch_size,
epochs=epochs,
device=device,
workers=4, # Número de trabajadores para la carga de datos
augment=True, # Habilita el aumento de datos
verbose=True, # Muestra información detallada durante el entrenamiento
# learning_rate=0.01, # Puedes especificar una tasa de aprendizaje personalizada
# weight_decay=0.0005, # Agrega regularización si es necesario
)
if __name__ == "__main__":
train_yolo()
El script comienza definiendo las rutas para:
video_path
: La ruta del video de entrada que se va a procesar.model_path
: Modelo YOLO para la detección general de objetos.license_plate_detector_model_path
: Modelo YOLO específico para la detección de matrículas.
video_path = 'C0142.mp4'
model_path = 'yolo11n.pt'
license_plate_detector_model_path = 'runs2/detect/train9/weights/best.pt'
Define rutas y configuraciones de salida para el video y el archivo CSV, incluyendo las clases a detectar:
output_video_path = 'output_video.mp4'
csv_file_path = 'detection_tracking_log.csv'
show_video = True
classes_to_detect = [0, 1, 2, 3, 5]
Se inicializan los modelos YOLO y el detector de matrículas, además de un lector OCR (easyocr
) para la extracción de texto de matrículas.
model = YOLO(model_path)
license_plate_detector = YOLO(license_plate_detector_model_path)
reader = easyocr.Reader(['en'], gpu=True)
Real-ESRGAN mejora la calidad de imagen de las matrículas antes del OCR.
model_esrgan = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=6, num_grow_ch=32, scale=4)
model_path_esrgan = 'RealESRGAN_x4plus_anime_6B.pth'
upsampler = RealESRGANer(scale=4, model_path=model_path_esrgan, model=model_esrgan, ...)
El código prepara el video para su captura utilizando cv2.VideoCapture
y configura el video de salida.
cap = cv2.VideoCapture(video_path)
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
fps = cap.get(cv2.CAP_PROP_FPS)
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
out = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height))
El código entra en un bucle que procesa cada fotograma del video e incrementa el contador de fotogramas:
ret, frame = cap.read()
frame_number += 1
YOLO detecta objetos en el fotograma según classes_to_detect
. Para cada objeto detectado:
- Extracción de Coordenadas y Clase: Obtiene la caja delimitadora y la confianza del objeto.
- Seguimiento de ID Único: Cuenta e identifica objetos únicos usando
track_id
. - Almacenamiento de Datos del Objeto: Guarda datos como clase, confianza y detalles del fotograma en
object_info
. - Anotación: Dibuja cajas alrededor de cada objeto detectado y añade etiquetas de clase y confianza.
results = model.track(frame, persist=True, classes=classes_to_detect)
Para cada vehículo detectado (auto, motocicleta, autobús):
- Región de Interés (ROI) del Vehículo: Recorta la región del vehículo detectado en el fotograma.
- Detección de Matrículas: Ejecuta el modelo YOLO de matrículas en la región recortada.
- Mejora de Imagen con Real-ESRGAN: Mejora la calidad de la imagen de la matrícula.
- Extracción de Texto con OCR: Extrae el texto de la matrícula con
easyocr
, guardando el texto con mayor confianza enobject_info
. - Anotaciones: Dibuja cajas alrededor de las matrículas y muestra el texto en el fotograma.
vehicle_img = frame[y1:y2, x1:x2]
plate_results = license_plate_detector.predict(vehicle_img)
output, _ = upsampler.enhance(np.array(license_plate_roi), outscale=4)
plate_ocr_results = reader.readtext(enhanced_license_plate, allowlist='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ')
Después de procesar todos los fotogramas, la información de detección de objetos se guarda en un archivo CSV, y se liberan los recursos para evitar problemas de memoria.
with open(csv_file_path, mode='w', newline='') as file:
writer = csv.writer(file)
writer.writerow([...])
for track_id, info in object_info.items():
writer.writerow([...])
cap.release()
out.release()
cv2.destroyAllWindows()
-
Primero, navega a la carpeta de tu proyecto y ejecuta los siguientes comandos:
# Instalar Git (si no lo tienes ya instalado) conda install git # Clonar el repositorio de Real-ESRGAN git clone https://github.com/xinntao/Real-ESRGAN # Navegar dentro del directorio del proyecto cd Real-ESRGAN # Instalar dependencias pip install basicsr pip install facexlib pip install gfpgan pip install -r requirements.txt # Configurar el entorno de desarrollo python setup.py develop
-
Descargar el modelo preentrenado:
Descarga el archivo del modelo desde el siguiente enlace y colócalo en la carpeta raíz del proyecto:
Para resolver un error que puede ocurrir, edita el archivo degradations.py
en tu entorno.
-
Localiza el archivo en:
C:\Users\<tu_usuario>\anaconda3\envs\VC_P4\Lib\site-packages\basicsr\data\degradations.py
-
Busca la línea:
from torchvision.transforms.functional_tensor import rgb_to_grayscale
-
Reemplázala por:
from torchvision.transforms.functional import rgb_to_grayscale
Esto debería corregir el problema y completar el proceso de instalación.
Este proyecto incluye funcionalidades avanzadas para la anonimización de personas y matrículas en el video. A continuación se detalla cada una:
- Anonimización de Personas: Detecta y aplica un efecto de desenfoque a las personas en el video.
- Anonimización de Matrículas: Para vehículos identificados, se aplica desenfoque sobre las matrículas visibles.
- Control de Anonimización con la tecla "B": La tecla "B" habilita o deshabilita el efecto de desenfoque de manera dinámica durante el procesamiento del video. Esto permite al usuario decidir, en tiempo real, si se quiere aplicar el efecto de anonimización.
- YOLO Documentation: ultralytics.com/yolo
- PyTorch Documentation: pytorch.org
- Tesseract Documentation: github.com/tesseract-ocr
- EasyOCR Documentation: github.com/JaidedAI/EasyOCR
- OpenCV Documentation: docs.opencv.org
- CUDA Documentation: developer.nvidia.com/cuda-toolkit
- Real-ESRGAN Documentation: Real-ESRGAN Documentation
- RRDBNet Documentation: RRDBNet Documentation