IDENTIFICACIÓN DE MATRÍCULAS HACIENDO USO DE ESP32CAM Y RECONOCIMIENTO DE DAÑOS EN VEHÍCULOS POR MEDIO DE REDES NEURONALES CONVOLUCIONALES TRABAJO FIN DE MÁSTER CURSO 2022-2023 AUTOR KEVIN FABIÁN RODRÍGUEZ COLLAZOS DIRECTOR YOLANDA GARCÍA RUIZ MÁSTER EN INTERNED DE LAS COSAS FACULTAD DE INFORMÁTICA UNIVERSIDAD COMPLUTENSE DE MADRID IDENTIFICACIÓN DE MATRÍCULAS HACIENDO USO DE ESP32CAM Y RECONOCIMIENTO DE DAÑOS EN VEHÍCULOS POR MEDIO DE REDES NEURONALES CONVOLUCIONALES TRABAJO DE FIN DE MÁSTER EN INTERNED DE LAS COSAS DEPARTAMENTO DE SISTEMAS INFORMÁTICOS Y COMPUTACIÓN AUTOR KEVIN FABIÁN RODRÍGUEZ COLLAZOS DIRECTOR YOLANDA GARCÍA RUIZ CONVOCATORIA: SEPTIEMBRE 2023 CALIFICACIÓN: 7.0 MÁSTER EN INTERNED DE LAS COSAS FACULTAD DE INFORMÁTICA UNIVERSIDAD COMPLUTENSE DE MADRID 15 DE AGOSTO DE 2023 III DEDICATORIA A Fabián, Luz Elena, Isabella y Johana. Porque el ejemplo es más fuerte que las reglas. “Carpe Diem” V AGRADECIMIENTOS A todos los que han creído en mí y me han acompañado en este nuevo camino, especialmente a Diana Marcela Meléndez Gonzalez porque sin su apoyo esto no hubiese sido posible. A mi directora Yolanda García Ruiz, por su paciencia y apoyo incondicional en la elaboración de este trabajo. VII RESUMEN Este trabajo final de máster tiene como objetivo desarrollar un sistema automatizado de bajo coste que combine la detección de matrículas vehiculares mediante OCR empleando un dispositivo ESP32CAM y el reconocimiento de ciertos tipos de daños en vehículos utilizando redes neuronales convolucionales (CNN) haciendo uso de las cámaras existentes en la compañía. En cuanto a la detección de matrículas, se emplean técnicas de visión por computadora para identificar y localizar las regiones que contienen las matrículas en imágenes de vehículos del Holding empresarial PROMOAMBIENTAL de Colombia. De tal forma que una vez se tenga identificado cada vehículo, se pueda realizar una valoración automatizado de las zonas del tren delantero de los vehículos para detectar los daños más comunes que se producen en la flota de vehículos, lo cual se pretende realizar con técnicas basadas en redes neuronales convolucionales entrenadas con un conjunto de imágenes etiquetadas que contienen diferentes tipos de daños. El objetivo de utilizar este sistema de identificación de daños en la flota de vehículos es reducir los tiempos de dedicación, logrando optimizar mediante la automatización un proceso que actualmente solo depende de la supervisión humana, por medio de una herramienta tecnológica orientada a IOT. Palabras clave OCR, ESP32CAM, CNN, IOT, Visión por computadora IX ABSTRACT This final master's project aims to develop a low-cost automated system that combines the detection of vehicle license plates by OCR using an ESP32CAM and the recognition of certain types of vehicle damage using convolutional neural networks (CNN) making use of existing cameras in the company. As for the detection of license plates, computer vision techniques are used to identify and locate the regions that contain the license plates in vehicle images of the PROMOAMBIENTAL Business Holding of Colombia. In such a way that once each vehicle has been identified, an automated evaluation can be carried out in the areas of the front end of the vehicles to detect the most common damages that occur in the vehicle fleet, which is intended to be carried out with techniques based on in convolutional neural networks trained with a set of labeled images containing different types of damage. The objective of using this damage identification system in the vehicle fleet is to reduce dedication times, managing to optimize through automation a process that currently only depends on human supervision, through a technological tool oriented to IOT. Keywords OCR, ESP32CAM, CNN, IOT, Computer vision X ÍNDICE DE CONTENIDOS Dedicatoria ................................................................................................................................... III Agradecimientos .......................................................................................................................... V Resumen ...................................................................................................................................... VII Abstract ........................................................................................................................................ IX Índice de contenidos ................................................................................................................... X Índice de figuras ......................................................................................................................... XIII Índice de tablas ........................................................................................................................ XVII Capítulo 1 - Introducción ............................................................................................................ 1 1.1 Motivación .......................................................................................................................... 2 1.2 Objetivos .............................................................................................................................. 3 1.3 Plan de trabajo ................................................................................................................... 3 Capítulo 2 - Tecnologías para el Desarrollo del Proyecto ...................................................... 5 2.1. ESP32 ......................................................................................................................... 5 2.2. ESP32CAM................................................................................................................ 7 2.3. Sensor OV2640 ........................................................................................................ 9 2.4. Protocolo HTTP ...................................................................................................... 11 2.5. Arduino ................................................................................................................... 12 2.6. Sensor Sharp OA41SK ......................................................................................... 12 2.7. Python ..................................................................................................................... 13 2.8. Flask Framework ................................................................................................... 13 2.9. PyTesseract ............................................................................................................ 14 2.10. OpenCV ................................................................................................................. 15 XI 2.11. CNN ......................................................................................................................... 15 2.12. Mask-RCNN ........................................................................................................... 16 Capítulo 3 - Algoritmos para Tratamiento de Imágenes ...................................................... 17 3.1 Algoritmo de GrayScale .................................................................................................. 17 3.2 Algoritmo de Threshold .................................................................................................... 19 3.3 Algoritmo de Find Contours ............................................................................................ 20 3.4 Algoritmo de “Filter Candidates”................................................................................... 21 3.5 Algoritmo de “Lowest Candidate” ................................................................................ 23 3.6 Algoritmo de “Crop Candidate” ................................................................................... 24 3.7 Algoritmo de Adaptative Threshold .............................................................................. 25 3.8 Algoritmo de Clear Border .............................................................................................. 26 Capítulo 4 - Desarrollo del Proyecto ........................................................................................ 27 4.1 Esquema Funcional del Proceso .................................................................................... 28 4.2 Servidor Web ESP32 CAM ................................................................................................ 28 4.3 Servidor Web OCR ........................................................................................................... 32 4.3.1 Secuencia de Servidor Web OCR con ESP32 CAM ............................................. 34 4.4 Cliente HTTP ESP32 con Sensor Sharp ............................................................................ 36 4.4.1 Firmware del Cliente HTTP ........................................................................................ 37 4.5 OCR Server con Cámara de la Empresa...................................................................... 42 4.6 Predicción de Daños con Mask R-CNN ........................................................................ 46 Capítulo 5 - Conclusiones y trabajo futuro ............................................................................. 51 5.1 Conclusiones ..................................................................................................................... 51 5.2 Trabajo Futuro ................................................................................................................... 52 Capítulo 6 - Introduction ........................................................................................................... 53 6.1 Motivation ......................................................................................................................... 54 XII 6.2 Objetives ............................................................................................................................ 55 6.3 Workplan............................................................................................................................ 55 Capítulo 7 - Conclusions and Future Work .............................................................................. 57 7.1 Conclusions ....................................................................................................................... 57 7.2 Future Work........................................................................................................................ 58 Bibliografía ................................................................................................................................... 59 XIII ÍNDICE DE FIGURAS Ilustración 1diagrama funcional del nodo ESP32. Fuente: Datasheet ESP32 Espressif [14] 6 Ilustración 2 Entradas y salidas de un ESP32. Fuente: Artículo Platform for hands-on remote labs based on the ESP32 and NOD-red. [2]. ....................................................... 7 Ilustración 3 Hardware del nodo ESP32 CAM – AI Thinker. Fuente: Datasheet ESP32 CAM AI Thinker [15]. ....................................................................................................................... 8 Ilustración 4 entradas y salidas del ESP32 CAM. Fuente: Datasheet ESP32 CAM AI Thinker [15] .......................................................................................................................................... 9 Ilustración 5 ESP32 CAM junto al sensor OV2640. Fuente: Datasheet OV2640 Einstronic Enterprise [16]. ..................................................................................................................... 10 Ilustración 6 Diagrama funcional del Sensor OV2640. Fuente: Datasheet Uctronics Enterprise [17]. ..................................................................................................................... 11 Ilustración 7 Hardware del sensor Sharp OA41SK. Fuente: Datasheet OA41SK Octopart [17]. ....................................................................................................................................... 13 Ilustración 8 Vehículo compactador en base de operaciones. Fuente: Propia .............. 18 Ilustración 9 Vehículo compactador en escala de grises. Fuente: Propia ........................ 19 Ilustración 10 Vehículo compactador con filtro Threshold. Fuente: Propia ....................... 20 Ilustración 11 Vehículo compactador con algoritmo de Find Contours. Fuente: Propia 21 Ilustración 12 Resultado de algoritmo de “Filter Candidates”. Fuente: Propia ................. 22 Ilustración 13 Resultado de algoritmo “Lowest Candidates”. Fuente: Propia .................. 24 Ilustración 14 ROI extraida con algoritmo de “Crop Candidate”. Fuente: Propia ........... 25 Ilustración 15 ROI con algoritmo de “Adaptative Threshold”. Fuente: Propia .................. 26 Ilustración 16 ROI Umbralizada con algoritmo de “Clear Border” invertido. Fuente: Propia ............................................................................................................................................... 27 Ilustración 17 Esquema funcional de la solución IOT. Fuente: Propia................................. 28 Ilustración 18 Firmware de Espressif Web Server ESP32 CAM. Fuente: Propia .................. 29 XIV Ilustración 19 Aplicación Web Server ESP32 CAM. Fuente: Propia ..................................... 30 Ilustración 20 Captura de foto desde Web Server ESP32 CAM. Fuente: Propia ............... 30 Ilustración 21 Petición de Captura de foto desde Web Server ESP32 CAM. Fuente: Propia ............................................................................................................................................... 31 Ilustración 22 Estructura de la petición HTTP al Web Server ESP32 CAM. Fuente: Propia 31 Ilustración 23 OCR Servidor Web, código bloque configuración. Fuente: Propia ........... 32 Ilustración 24 OCR Servidor Web, código bloque captura de foto. Fuente: Propia ........ 33 Ilustración 25 OCR Server, código bloque tratamiento de imagen. Fuente: Propia ....... 34 Ilustración 26 Captura de imagen con petición a ESP32 CAM Web Server. Fuente: Propia ............................................................................................................................................... 34 Ilustración 27 Identificación de ROI en la imagen. Fuente: Propia ..................................... 34 Ilustración 28 Binarización de la ROI. Fuente: Propia ............................................................ 35 Ilustración 29 Reducción de ruido en bordes. Fuente: Propia ............................................. 35 Ilustración 30 Inversión de la imagen y lectura. Fuente: Propia .......................................... 35 Ilustración 31 Petición realizada desde un navegador al endpoint. Fuente: Propia ....... 36 Ilustración 32 Montaje de HTTP Cliente en ESP32. Fuente: Propia ....................................... 37 Ilustración 33 Cliente HTTP ESP32, código bloque de configuración. Fuente: Propia ...... 38 Ilustración 34 Cliente HTTP ESP32, código bloque de verificación. Fuente: Propia .......... 39 Ilustración 35 Verificación OCR Web Server Disponible. Fuente: Propia............................ 39 Ilustración 36 Cliente HTTP ESP32, Lectura del puerto serial. Fuente: Propia ..................... 40 Ilustración 37 Cliente HTTP ESP32, Indicador LED. Fuente: Propia ........................................ 41 Ilustración 38 Cliente HTTP ESP32, Llamado a endpoint. Fuente: Propia ............................ 42 Ilustración 39 Orden de ejecución de algoritmos en Python para OCR. Fuente: Propia 43 Ilustración 40 Vehículo compactador original en base de operaciones. Fuente: Propia ............................................................................................................................................... 43 XV Ilustración 41 Vehículo compactador con algoritmo GrayScale. Fuente: Propia ........... 44 Ilustración 42 Vehículo con algoritmo de binarización. Fuente: Propia ............................. 44 Ilustración 43 Vehículo compactador con algoritmo de contornos. Fuente: Propia ...... 45 Ilustración 44 Resultado de algoritmo de candidatos. Fuente: Propia .............................. 45 Ilustración 45 Imagen con algoritmo de corte en ROI. Fuente: Propia .............................. 45 Ilustración 46 ROI con algoritmo de binarización. Fuente: Propia ...................................... 46 Ilustración 47 ROI con algoritmo limpieza de bordes. Fuente: Propia ................................ 46 Ilustración 48 Imagen con algoritmo de inversión de imagen. Fuente: Propia ................ 46 Ilustración 49 Etiquetado de Imágenes. Fuente: Propia ....................................................... 47 Ilustración 50 Subconjuntos de datos. Fuente: Github Louisyuzhe ..................................... 48 Ilustración 51 Evaluación del modelo. Fuente: Github Louisyuzhe ..................................... 49 Ilustración 52 Despliegue del modelo. Fuente: Github Louisyuzhe ..................................... 50 XVII ÍNDICE DE TABLAS 1 Capítulo 1 - Introducción En la búsqueda de la mejora continua, optimización del tiempo y mejores prácticas, la tecnología representa el medio a través del cual se potencian soluciones que aportan agilidad, enfoque y precisión permitiendo al negocio y personas dedicar tiempo en las actividades que aporten mayor valor (core del negocio). Es por ello por lo que la identificación de actividades repetitivas y la búsqueda de la eficiencia propician el uso de tecnologías como los sistemas IOT garantizando así una menor dedicación de tiempo en actividades mecánicas. El avance tecnológico en ciertos campos ha permitido pluralizar las tecnologías que pueden ser empleadas para atender diferentes áreas de las empresas y así crear entornos de soluciones heterogéneas que atienden procesos que hace algunos años eran impensables. Este es el caso de la visión por computador, que en la actualidad es uno de los campos más llamativos para subsanar muchas necesidades en las empresas. En general los procesos que son objeto de estudio para la automatización son aquellos que tienen un mayor impacto en factores como: tiempo dedicación, riesgo y costes en su ejecución. El Holding PROMOAMBIENTAL es una compañía dedicada al servicio de aseo urbano que tiene cobertura en múltiples departamentos de Colombia y que se encuentra vigilada por instituciones regulatorias, teniendo como uno de sus requisitos que la flota de sus vehículos se encuentre en las mejores condiciones físicas para garantizar la seguridad los empleados y dar un respaldo en los distritos donde prestan sus servicios, dado que esta actividad está regulada bajo un marco normativo y contractual. Esta empresa tiene la obligación de mantener la flota de vehículos en las mejores condiciones, por lo que cuenta con un área dedicada a gestionar todo el ciclo de vida de la misma. Por lo tanto, si un vehículo presenta daños o averías en áreas identificadas de interés, se someterá a un proceso de recuperación hasta que el daño sea reparado. Este proceso es fundamental y evidencia la necesidad del desarrollo de un sistema IOT. Actualmente existen daños que no son identificados oportunamente, lo que representa 2 a la empresa incumplimientos, sanciones y una dedicación de tiempo por parte de los empleados que, aunque es elevada, no garantiza la eficiencia. 1.1 Motivación La compañía PROMOAMBIENTAL ubicada en la ciudad de Bogotá D.C, en Colombia. actualmente realizar la prestación del servicio de aseo público en una de las zonas más grandes de la ciudad. Esta compañía tiene una flota de más de cien vehículos para su operación diaria. Esta flota debe ser mantenida en condiciones óptimas para la prestación del servicio, por lo que es necesario monitorearla diariamente para garantizar que no presente daños que puedan afectar el desempeño de estas labores. Es por esto que la compañía cuenta con una serie de cámaras que recogen el estado de los vehículos en el momento de la entrada y salida, para que posteriormente un operador capture los datos de la matrícula y los posibles daños que tienen, para finalmente depositarlos en una serie de hojas de Excel. Esta situación tiene dos asuntos que se convierten en necesidades para garantizar una solución eficiente. Uno de estos, es tener la capacidad de identificar cada uno de los vehículos basado en su matrícula; pero que con las cámaras que cuenta la compañía, al no tener ningún tipo de conectividad, supone una restricción. Por lo que nace la idea de hacerlo con un ESP32CAM que es un nodo IoT de bajo coste con interfaces Wifi y Bluetooth, tiene también una cámara que puede ser conectada como periférico. Y aunque las fotos tomadas con este no serán de gran calidad, esto supone un reto muy interesante para el caso de estudio. También existe la necesidad de identificar oportunamente los daños más comunes que se dan en la flota de vehículos. De momento se tiene delimitado como área de interés el tren delantero de estos, que es en donde se concentran los daños de mayor impacto. Por lo tanto, en este trabajo, se pretende desarrollar una solución IOT que resuelva el problema de la eficiencia en la identificación de los vehículos que entran y/o salen de la base de operaciones y los daños que sufren de acuerdo a su operación diaria. Priorizando el menor coste posible para el desarrollo del mismo y garantizando que la arquitectura de la solución sea escalable de cara al futuro. 3 1.2 Objetivos A continuación, se describen los objetivos que se persiguen con el desarrollo de este trabajo. En primer lugar, se pretende desarrollar un servidor de captura de imágenes en el dispositivo ESP32CAM que pueda ser gestionado por un protocolo de comunicación estándar, de tal forma que éste pueda ser un nodo en la arquitectura de la solución. En consecuencia, al primer objetivo, las imágenes tomadas por este nodo deberán ser enviadas a un nodo de identificación de matrículas. Por lo que será necesario desarrollar un software (OCR) que permita la identificación de texto con base en imágenes. Además, se pretende que las fotos capturadas por las cámaras de la compañía, destinadas a la detección de averías, sean enviadas a un nodo especializado en identificar daños. Este nodo confirmará si hay daños en las áreas de interés. Por lo tanto, se necesita crear un software que, basándose en una imagen, pueda determinar si existen daños. Esto se logrará mediante el uso de redes neuronales convolucionales (CNN) en combinación con algoritmos ya existentes. 1.3 Plan de trabajo El plan de trabajo que se va a llevar a cabo para cumplir con los objetivos planteados empieza por realizar acercamientos al proceso de tratamiento de imágenes y de aprendizaje profundo en este contexto, con el fin de adoptar los conocimientos necesarios para hacer uso de esta tecnología y así aplicarlas en las situaciones que demanda este proyecto. Para lograr que este conocimiento se encuentre afianzado, será necesario investigar sobre las técnicas más idóneas, modos de funcionamiento, ventajas y limitaciones que pudiesen ser de aprovechamiento para el desarrollo de la solución planteada. Posteriormente, será necesario estudiar sobre los aspectos técnicos del chip ESP32CAM tanto en su componente software como de hardware. El enfoque principal será comprender las capacidades ofrecidas por su cámara, ya que esto será fundamental en el proceso de identificación. De tal forma que de acuerdo a estas 4 características y los diferentes experimentos realizados en cuanto a distancias, iluminación y demás factores sea posible determinar un escenario idóneo de identificación. Una vez conocidas las características esenciales del dispositivo ESP32CAM, se seleccionará el entorno de desarrollo adecuado para cargar el Firmware en el dispositivo. Este firmware se encargará de capturar imágenes de los vehículos para su identificación, y será desarrollado con las funcionalidades necesarias. Simultáneamente, se desarrollará el nodo de reconocimiento de texto basado en imágenes. Dicho nodo procesará las imágenes capturadas por el dispositivo ESP32CAM y realizará la predicción del texto presente en ellas. También se desarrollará un algoritmo que pueda ser entrenado con un conjunto de datos personalizable, que será el encargado de identificar los daños en la flota de vehículos y de notificarlo por medio de un protocolo de comunicación específico. 5 Capítulo 2 - Tecnologías para el Desarrollo del Proyecto En este capítulo se va a presentar los componentes lógicos como lenguajes de programación, protocolos de comunicación, herramientas y el hardware que se usará en el proyecto. También se detallará a nivel arquitectónico la interacción que tiene cada uno de estos como nodo individual y su aporte en la solución integral. Además, se presentan los diagramas conceptuales del proceso, de tal forma que se tenga claridad del proceso a desarrollar. 2.1. ESP32 El ESP32 (Espressif ESP32, s.f.) es un microcontrolador de bajo costo y alto rendimiento diseñado por Espressif Systems. Técnicamente, es un sistema en chip (SoC) que combina un procesador de doble núcleo de 32 bits, basado en la arquitectura Xtensa LX6 de Tensilica, con conectividad Wi-Fi y Bluetooth. Posee una velocidad de reloj de hasta 240 MHz, memoria RAM integrada y una variedad de interfaces periféricas como GPIO, UART, SPI, I2C y ADC. El ESP32 ofrece amplias capacidades de conectividad inalámbrica, lo que lo convierte en una elección popular para proyectos de Internet de las cosas (IoT), automatización del hogar, desarrollo de prototipos y aplicaciones de baja potencia. Además, es altamente programable y admite entornos de desarrollo como Arduino IDE, ESP-IDF y MicroPython, permitiendo a los desarrolladores crear aplicaciones de manera sencilla y eficiente. Su versatilidad, combinada con su precio asequible, ha hecho del ESP32 una opción preferida en el mundo de la electrónica y la informática embebida. El dispositivo ESP32 contiene múltiples componentes funcionales, (ver Ilustración 1diagrama funcional del nodo ESP32. Fuente: Datasheet ESP32 Espressif [14]) tales como interfaces de conexión, buses de lectura, unidades de almacenamiento volátiles y no volátiles, etc. 6 Ilustración 1diagrama funcional del nodo ESP32. Fuente: Datasheet ESP32 Espressif [14] Los pines de un ESP32 son conexiones físicas en la placa del microcontrolador (ver Ilustración 2 Entradas y salidas de un ESP32. Fuente: Artículo Platform for hands-on remote labs based on the ESP32 and NOD-red. [2].) que permiten interactuar con dispositivos externos y realizar diversas funciones. Estos pines pueden configurarse como entradas o salidas digitales, entradas o salidas analógicas, pines de comunicación serial, pines de control de energía y más. En resumen, los pines de un ESP32 se utilizan para conectar y controlar componentes electrónicos y periféricos, lo que permite una amplia gama de aplicaciones, desde el control de sensores hasta la comunicación con otros dispositivos. 7 Ilustración 2 Entradas y salidas de un ESP32. Fuente: Artículo Platform for hands-on remote labs based on the ESP32 and NOD-red. [2]. 2.2. ESP32CAM ESP32CAM es un chip que ofrece las prestaciones habituales de la familia de ESP32, pero con una característica adicional de gran relevancia, y es que cuenta con una cámara de bajas prestaciones pero que puede llegar a ser útil en diferentes situaciones. Cuenta con las funcionalidades habituales que son necesarias para un despliegue IOT, tales como: conectividad WiFi y módulo de Bluetooth (ver IIlustración 3 Hardware del nodo ESP32 CAM – AI Thinker. Fuente: Datasheet ESP32 CAM AI Thinker [15]. Adicionalmente cuenta con una serie de puertos GPIO que permiten ser usados para conectar periféricos u otros sensores, también cuenta con una ranura para una microSD de tal forma que esta pueda hacer las veces de unidad de almacenamiento en caso de ser necesario. Este módulo permite pluralidad en las tecnologías en que se desarrolla su firmware dado que, es posible hacer uso de Arduino, ESP-IDF e incluso versiones reducidas de Python como Micro Python. 8 Ilustración 3 Hardware del nodo ESP32 CAM – AI Thinker. Fuente: Datasheet ESP32 CAM AI Thinker [15]. Los pines de un ESP32-CAM son conexiones físicas en la placa del microcontrolador ESP32-CAM que permiten interactuar con diversos dispositivos y realizar funciones específicas. Estos pines se utilizan para conectar la cámara OV2640, controlar la captura de imágenes, transmitir datos por Wi-Fi (ver Ilustración 4 entradas y salidas del ESP32 CAM. Fuente: Datasheet ESP32 CAM AI Thinker [15] , interactuar con sensores, y en general, para habilitar una variedad de aplicaciones de visión por computadora y comunicación inalámbrica. 9 Ilustración 4 entradas y salidas del ESP32 CAM. Fuente: Datasheet ESP32 CAM AI Thinker [15] 2.3. Sensor OV2640 La cámara OV2640 (Uctronics OV2640, s.f.) es un módulo de cámara digital desarrollado por OmniVision Technologies. Técnicamente, es un sensor de imagen CMOS (Complementary Metal-Oxide-Semiconductor) que cuenta con una matriz de píxeles de 2 megapíxeles (1600x1200). Utiliza tecnología avanzada de procesamiento de imágenes y ofrece una amplia gama de funciones, como la captura de imágenes fijas y la grabación de video en diferentes resoluciones. El sensor OV2640 integra una lente y un sistema de procesamiento de imágenes, lo que permite obtener imágenes de calidad modesta y un rendimiento óptimo en diversas condiciones de iluminación. Además, es capaz de realizar funciones como el enfoque automático, el control de exposición, la corrección de color y el balance de blancos. 10 Gracias a su tamaño compacto y bajo consumo de energía, la cámara OV2640 (ver Ilustración 5 ESP32 CAM junto al sensor OV2640. Fuente: Datasheet OV2640 Einstronic Enterprise [16]. es ampliamente utilizada en dispositivos portátiles, aplicaciones de video vigilancia, proyectos de Internet de las cosas (IoT) y sistemas de seguridad. Su capacidad para capturar imágenes nítidas y vívidas la convierte en una opción popular para diversas aplicaciones que requieren capacidades de captura de imágenes en tiempo real. Ilustración 5 ESP32 CAM junto al sensor OV2640. Fuente: Datasheet OV2640 Einstronic Enterprise [16]. el sensor OV2640 es un dispositivo que convierte la luz en señales digitales (ver Ilustración 6 Diagrama funcional del Sensor OV2640. Fuente: Datasheet Uctronics Enterprise [17].) que representan una imagen. Estas señales se pueden utilizar en diferentes aplicaciones de visión por computadora. 11 Ilustración 6 Diagrama funcional del Sensor OV2640. Fuente: Datasheet Uctronics Enterprise [17]. 2.4. Protocolo HTTP El protocolo HTTP (IBM Http, s.f.) es un estándar de comunicación utilizado en la internet para la transferencia de datos entre un cliente (por ejemplo, un navegador web) y un servidor. Técnicamente, HTTP es un protocolo de capa de aplicación que opera sobre el protocolo de transporte TCP (Transmission Control Protocol) o, en casos específicos, sobre el protocolo UDP (User Datagram Protocol). Cuando un cliente realiza una solicitud HTTP a través de un navegador, se establece una conexión con el servidor web. La solicitud incluye un método (como GET, POST, PUT, DELETE) y una URL que identifica el recurso que se desea acceder. El servidor procesa la solicitud y devuelve una respuesta, que incluye un código de estado y los datos solicitados, como una página web o un archivo. El protocolo HTTP se basa en el concepto de solicitud y respuesta, lo que permite la transferencia de recursos como texto, imágenes, videos y otros tipos de contenido. Además, HTTP puede funcionar con cifrado SSL/TLS, lo que da lugar al protocolo HTTPS para garantizar la seguridad de la comunicación y la privacidad de los datos transmitidos. En resumen, HTTP es esencial para la navegación web y la transferencia de información en Internet, permitiendo la interacción fluida entre los usuarios y los servidores para acceder y compartir recursos en línea. 12 2.5. Arduino Arduino es una plataforma de hardware y software de código abierto diseñada para la creación de proyectos electrónicos interactivos y dispositivos embebidos. Técnicamente, se compone de una placa de microcontrolador y un entorno de desarrollo integrado (IDE) que facilita la programación y la interacción con diversos componentes electrónicos. La placa Arduino se basa en microcontroladores de la familia AVR o ARM, que incluyen un procesador central, memoria RAM, entradas y salidas digitales y analógicas, así como interfaces de comunicación como UART, I2C y SPI. El IDE de Arduino proporciona una interfaz gráfica para escribir, compilar y cargar programas en la placa. Los programas de Arduino, llamados "sketches", están escritos en un lenguaje de programación C/C++ simplificado, y se ejecutan en el microcontrolador. Los desarrolladores pueden acceder a bibliotecas predefinidas para controlar componentes como sensores, actuadores y pantallas, lo que facilita la implementación de proyectos sin necesidad de conocimientos profundos en programación de bajo nivel. 2.6. Sensor Sharp OA41SK El Sensor Sharp OA41SK (Datasheet 0a41sk, s.f.) es un dispositivo electrónico utilizado para medir distancias mediante el principio de la reflexión de la luz infrarroja. Técnicamente, este sensor es un tipo de sensor de proximidad óptico (ver Ilustración 7 Hardware del sensor Sharp OA41SK. Fuente: Datasheet OA41SK Octopart [17]. que emplea un diodo emisor de luz infrarroja (LED) y un receptor de luz infrarroja (fototransistor) para calcular la distancia entre el sensor y un objeto. El proceso funciona de la siguiente manera: el LED emite luz infrarroja hacia un objeto cercano, y parte de esta luz se refleja de vuelta al sensor. El receptor de luz infrarroja detecta la luz reflejada, y la intensidad de esta luz reflejada se utiliza para determinar la distancia al objeto. A medida que el objeto se acerca al sensor, la intensidad de la luz reflejada aumenta. Puede medir distancias en un rango específico, generalmente desde unos pocos centímetros hasta varios metros, dependiendo del modelo y las condiciones ambientales. Este tipo de sensor ofrece una forma sencilla y eficaz de obtener información sobre la proximidad de objetos en un entorno, lo que lo convierte en una herramienta valiosa para proyectos de IoT. 13 Ilustración 7 Hardware del sensor Sharp OA41SK. Fuente: Datasheet OA41SK Octopart [17]. 2.7. Python Python (Python Summary, s.f.) es un lenguaje de programación de alto nivel y de propósito general, conocido por su legibilidad y sintaxis sencilla. Técnicamente, Python es un lenguaje interpretado e interactivo que enfatiza la legibilidad del código y la facilidad de uso. Además, Python es utilizado en una variedad de aplicaciones, desde desarrollo web y análisis de datos hasta inteligencia artificial, IoT y automatización. En el contexto del proyecto será usado para el desarrollo del servidor web de OCR con ESP32 CAM, para el proceso de captura de fotografías desde HTTP, para el análisis de OCR con las fotos actuales de la compañía y para el entrenamiento de un modelo de aprendizaje para predicción de daños. 2.8. Flask Framework Flask es un framework de desarrollo web ligero y flexible para Python. Técnicamente, Flask es una biblioteca que proporciona herramientas y estructuras para crear aplicaciones web de manera eficiente y organizada. Flask se basa en el concepto de microframework, lo que significa que ofrece lo esencial para construir aplicaciones web, pero permite a los desarrolladores elegir y agregar las extensiones y componentes necesarios según sus necesidades específicas. 14 El corazón de Flask es su enrutador, que permite asociar URLs con funciones y vistas. Utilizando decoradores en Python, las rutas son definidas de manera clara y concisa. Flask también proporciona una capa de abstracción para manejar solicitudes y respuestas HTTP de manera sencilla, fomenta el uso de plantillas Jinja2, que permite la creación de vistas HTML dinámicas al combinar datos con la estructura HTML. Además, su sistema de plantillas facilita la reutilización de elementos visuales en la aplicación. Aunque Flask es minimalista en comparación con algunos frameworks más completos, su comunidad activa contribuye con una amplia gama de extensiones que añaden funcionalidad adicional, como la autenticación, la manipulación de formularios y la conexión a bases de datos. En el contexto del proyecto, Flask será usado para exponer las funcionalidades de OCR, captura de imágenes por medio de HTTP y las respuestas que dará bajo este protocolo a los clientes que lo soliciten. 2.9. PyTesseract PyTesseract (Pypi Org - Pytesseract, s.f.) es una interfaz de Python para el motor de reconocimiento óptico de caracteres (OCR) Tesseract. Técnicamente, PyTesseract permite a los desarrolladores utilizar las capacidades de OCR de Tesseract para extraer texto de imágenes y documentos escaneados. Tesseract es un software de OCR de código abierto que puede reconocer y convertir imágenes de texto en texto editable. PyTesseract facilita la integración de esta funcionalidad en proyectos de Python, permitiendo la extracción automatizada de contenido legible a partir de imágenes y PDFs. PyTesseract ofrece opciones para personalizar el proceso de reconocimiento, como ajustar idiomas, establecer configuraciones de procesamiento de imágenes y manejar diferentes formatos de salida. En resumen, PyTesseract es una herramienta valiosa para aplicaciones que requieran la extracción de texto de imágenes y documentos, como la digitalización de documentos impresos o la automatización de tareas de extracción de datos. Su capacidad para interactuar con Tesseract lo convierte en una solución poderosa para trabajar con contenido textual en imágenes. 15 2.10. OpenCV OpenCV (OpenCV - What is it, s.f.) es una biblioteca de visión por computadora de código abierto y ampliamente utilizada. Técnicamente, OpenCV ofrece una colección de algoritmos y funciones para procesar y analizar imágenes y videos en tiempo real, está escrita en C++ y dispone de interfaces para varios lenguajes, incluyendo Python. Permite a los desarrolladores realizar tareas como manipulación de imágenes, detección de objetos, reconocimiento facial, seguimiento de objetos, calibración de cámaras, y más. La biblioteca incluye una variedad de funciones para trabajar con imágenes y videos, como filtrado, segmentación, transformaciones geométricas, detección de bordes y más. Además, OpenCV ofrece módulos de aprendizaje automático para el análisis avanzado de datos visuales. En Python, los desarrolladores pueden aprovechar la facilidad de uso de OpenCV a través de su interfaz. Pueden cargar imágenes y videos, aplicar transformaciones, detectar características, y crear aplicaciones visuales interactivas. Esta librería será usada para el preprocesamiento de imágenes antes de pasarlas a cada OCR. También, será usada para los diferentes manejos en la detección de daños en vehículos. 2.11. CNN Las Convolutional Neural Networks (CNN), o Redes Neuronales Convolucionales en español, son un tipo de arquitectura de redes neuronales diseñadas para procesar y analizar datos visuales, como imágenes y videos. Técnicamente, las CNN son una evolución de las redes neuronales tradicionales, optimizadas para extraer automáticamente características y patrones relevantes de los datos visuales. Las CNN utilizan capas de convolución para aplicar filtros a la imagen de entrada, lo que permite detectar características como bordes, texturas y formas. Estas capas de convolución son seguidas por capas de agrupación (pooling) para reducir la dimensionalidad de las características extraídas y conservar las más importantes. 16 Una característica distintiva de las CNN es su capacidad para aprender jerarquías de características a medida que avanzan en las capas. Las capas iniciales capturan características simples, mientras que las capas posteriores combinan estas características para detectar objetos más complejos y abstracciones visuales. Las CNN se utilizan ampliamente en tareas de visión por computadora, como clasificación de imágenes, detección de objetos, segmentación semántica y reconocimiento facial. Gracias a su capacidad para capturar patrones en datos visuales, las CNN han revolucionado muchas áreas, incluyendo medicina, automoción, análisis de imágenes satelitales y más. En resumen, las Convolutional Neural Networks han demostrado ser altamente efectivas en el procesamiento y análisis de datos visuales, permitiendo a las máquinas comprender y extraer información significativa de imágenes y videos de manera automática y precisa. 2.12. Mask-RCNN Mask R-CNN (Mask Region-based Convolutional Neural Network) (Matlab - Mask R- CNN, s.f.) es una arquitectura avanzada de redes neuronales convolucionales diseñada para tareas de segmentación de instancias en imágenes. Técnicamente, Mask R-CNN es una extensión de la arquitectura Faster R-CNN que agrega la capacidad de generar máscaras de segmentación de alta precisión junto con la detección y clasificación de objetos. La arquitectura de Mask R-CNN consta de tres etapas principales: detección de objetos, generación de regiones de interés y segmentación de máscaras. La primera etapa utiliza una red convolucional para detectar objetos y predecir sus clases y cajas delimitadoras. Luego, se generan regiones de interés basadas en las detecciones previas. Finalmente, una red de segmentación genera máscaras binarias precisas para cada instancia detectada. La principal innovación de Mask R-CNN radica en su capacidad para segmentar objetos a nivel de píxel. Esto significa que puede identificar y delimitar no solo las ubicaciones de los objetos, sino también los píxeles individuales que pertenecen a cada objeto. Esto es particularmente útil en aplicaciones donde se requiere una segmentación precisa de 17 objetos superpuestos o cercanos. Mask R-CNN es ampliamente utilizado en áreas como visión por computadora gracias a sus características. Mask R-CNN será usada en el algoritmo de predicción de daños en vehículos para la segmentación de las regiones donde se encuentran los posibles daños. Capítulo 3 - Algoritmos para Tratamiento de Imágenes En este capítulo, se van a abordar los algoritmos fundamentales de procesamiento de imágenes que serán aplicados en los casos de uso específicos, como se ha detallado previamente. El enfoque central de este capítulo es detallar los algoritmos empleados para detectar las formas de interés presentes en las fotografías de los vehículos, para determinar la zona de interés donde se encuentra la matrícula. Inicialmente, se introducirán los algoritmos básicos utilizados, los cuales desempeñan un papel crucial en la preparación de las imágenes para otros pasos del pre- procesamiento. Posteriormente, se expondrá en detalle el algoritmo completo para la detección de formas que ha servido como punto de partida en este trabajo. Por último, se presentarán adaptaciones a dicho algoritmo que buscan optimizar su eficiencia y rendimiento sin sacrificar precisión. Estas modificaciones tienen como objetivo mejorar la capacidad del algoritmo en términos de velocidad y ejecución, manteniendo al mismo tiempo su capacidad para identificar con precisión las zonas donde se encuentran las matrículas de los vehículos. 3.1 Algoritmo de GrayScale El algoritmo de Grayscale (escala de grises) es una técnica utilizada en el procesamiento de imágenes para convertir una imagen en color en una versión en blanco y negro. Técnicamente, este algoritmo toma una imagen en color compuesta por píxeles con valores de color en los canales rojo, verde y azul (RGB), y los transforma en valores de intensidad de gris en una sola dimensión. El proceso de conversión implica promediar los valores de los canales rojo, verde y azul de cada píxel y asignar el valor 18 resultante a un solo canal de intensidad. Esto reduce la imagen a una escala de grises donde los tonos se representan en una intensidad de blanco al negro. La conversión a escala de grises es comúnmente utilizada para simplificar el análisis de imágenes y reducir la complejidad del procesamiento de datos visuales. Además, al eliminar la información de color, a menudo se puede resaltar mejor la estructura y los detalles de la imagen, especialmente en casos donde el color no es esencial y hay mayor interés por determinadas formas y/o patrones dependiendo de cada caso. En el contexto del proyecto, realizar esta conversión facilita significativamente la extracción de características visuales, que permitirán en una de las fases la primera aportación significativa para la identificación de la zona de interés. Inicialmente se tiene la imagen original, que es la foto tomada por las cámaras de la compañía (ver Ilustración 8 Vehículo compactador en base de operaciones. Fuente: Propia) en la base de operaciones. Ilustración 8 Vehículo compactador en base de operaciones. Fuente: Propia A la imagen original se le aplica el algoritmo de GrayScale (ver Ilustración 9 Vehículo compactador en escala de grises. Fuente: Propia) para dejarla con únicamente dos canales de color. 19 Ilustración 9 Vehículo compactador en escala de grises. Fuente: Propia 3.2 Algoritmo de Threshold El algoritmo de umbralización, también conocido como algoritmo de Threshold (OpenCV Thresholding, s.f.), es una técnica de procesamiento de imágenes que se utiliza para segmentar una imagen en áreas de interés basadas en niveles de intensidad de píxeles. Técnicamente, este algoritmo convierte una imagen en escala de grises en una imagen binaria (ver Ilustración 10 Vehículo compactador con filtro Threshold. Fuente: Propia), donde los píxeles se clasifican en dos grupos: aquellos por encima de un cierto umbral y aquellos por debajo. El proceso de umbralización implica elegir un valor umbral que divida los niveles de intensidad en dos categorías: píxeles que superan el umbral y píxeles que no lo hacen. Los píxeles que superan el umbral se asignan a un valor de píxel blanco (generalmente 255) y los que no lo superan se asignan a un valor de píxel negro (generalmente 0). La umbralización es útil para resaltar regiones de interés en una imagen que se distinguen por niveles de intensidad específicos. Puede utilizarse para segmentar objetos de fondo, resaltar bordes o aislar características particulares en una imagen. La elección del valor umbral puede variar según la aplicación y la naturaleza de la imagen. 20 Ilustración 10 Vehículo compactador con filtro Threshold. Fuente: Propia 3.3 Algoritmo de Find Contours El algoritmo de búsqueda de contornos (OpenCV Find Contours, s.f.) es una técnica utilizada en el procesamiento de imágenes para identificar y extraer bordes o contornos de objetos en una imagen. Técnicamente, este algoritmo analiza los cambios abruptos en la intensidad de píxeles para detectar las formas y límites de los objetos presentes en una imagen (ver Ilustración 11 Vehículo compactador con algoritmo de Find Contours. Fuente: Propia). El proceso de búsqueda de contornos implica varios pasos. Primero, la imagen se convierte generalmente a escala de grises para simplificar el análisis. Luego, se aplica un algoritmo de umbralización o de detección de bordes para resaltar las transiciones de intensidad en la imagen. Después de la umbralización, el algoritmo de búsqueda de contornos encuentra conjuntos de píxeles conectados que forman bordes o contornos. Estos conjuntos de píxeles se llaman contornos y pueden representar la forma externa de un objeto o contornos internos en el caso de objetos concéntricos. El algoritmo de búsqueda de contornos es sumamente útil en el contexto del proyecto dado que este permite la segmentación de imágenes, la medición de formas y áreas. Y 21 al detectar estos contornos podemos deducir la posible zona donde se encuentran las características de interés para así proporcionar información a los análisis posteriores. La biblioteca OpenCV, (OpenCV Definition, s.f.) por ejemplo, proporciona funciones específicas para encontrar contornos en imágenes, lo que facilita su implementación en proyectos de procesamiento de imágenes. El algoritmo de búsqueda de contornos es una técnica esencial en el procesamiento de imágenes que permite detectar y extraer bordes o contornos de objetos, lo que es fundamental para el proyecto, en el proceso de determinar la región de interés en donde se encuentra la matrícula de los vehículos. Ilustración 11 Vehículo compactador con algoritmo de Find Contours. Fuente: Propia 3.4 Algoritmo de “Filter Candidates” El algoritmo de "Filter Candidates" (OpenCV Canny, s.f.)se refiere a la técnica de aplicar filtros o criterios adicionales a los contornos encontrados en una imagen utilizando el algoritmo de búsqueda de contornos. Después de identificar los contornos en una imagen mediante el algoritmo de búsqueda de contornos, se realiza un proceso de filtrado para seleccionar específicamente los contornos que cumplen ciertos requisitos o características (ver Ilustración 12 Resultado de algoritmo de “Filter 22 Candidates”. Fuente: Propia). Este proceso de filtrado tiene como objetivo eliminar contornos no deseados o falsos positivos que puedan haber sido detectados debido a ruido o variaciones en la imagen. Puede implicar aplicar criterios como el área mínima o máxima de un contorno, la longitud del perímetro, la forma del contorno o cualquier otra característica relevante para el contexto específico. Por ejemplo, si se están buscando objetos circulares en una imagen y el algoritmo de búsqueda de contornos detecta contornos que no tienen una forma cercana a un círculo, puedes aplicar el "Filter Candidates" para eliminar esos contornos basados en su forma. De manera similar, si estás buscando objetos de un tamaño particular, puedes filtrar los contornos que no cumplen con ese tamaño basado en su relación de aspecto. El algoritmo de "Filter Candidates" en conclusión es una técnica que agrega un paso de filtrado después de identificar los contornos en una imagen. Esto mejora la calidad de los resultados al seleccionar contornos que cumplan con ciertos criterios, eliminando así contornos no deseados o irrelevantes. Ilustración 12 Resultado de algoritmo de “Filter Candidates”. Fuente: Propia 23 3.5 Algoritmo de “Lowest Candidate” El algoritmo de "Lowest Candidate" es una técnica que se refiere a la selección del candidato de menor valor entre los resultados filtrados después de aplicar filtros a los contornos detectados en una imagen utilizando el algoritmo "Filter Candidates", se elige el candidato que tenga el valor más bajo en función de cierta característica o propiedad. Este enfoque se utiliza cuando se desea seleccionar un candidato específico de entre varios que cumplen con los criterios de filtrado (ver Ilustración 13 Resultado de algoritmo “Lowest Candidates”. Fuente: Propia). Por ejemplo, si se están buscando objetos con áreas dentro de un rango específico y se ha aplicado el filtrado, es posible aplicar el algoritmo "Lowest Candidate" para elegir el objeto con el área más pequeña de entre los que cumplen con el criterio de filtrado. Esta técnica es útil cuando se necesita tomar una decisión basada en una métrica específica que debe ser mínima o máxima. Puede aplicarse en escenarios donde se desea identificar el objeto de menor tamaño, la intensidad de color más baja, la distancia más corta, entre otros. La combinación del algoritmo de filtrado con el "Lowest Candidate" permite una selección precisa del objeto que mejor cumple con los criterios de interés, lo que es esencial en aplicaciones de análisis de imágenes y visión por computadora. En resumen, el algoritmo de "Lowest Candidate" es una técnica que implica seleccionar el candidato con el valor más bajo entre los resultados filtrados, en función de una característica específica. Esto se utiliza para tomar decisiones basadas en métricas particulares, mejorando la precisión y la relevancia en la selección de objetos de interés en una imagen. 24 Ilustración 13 Resultado de algoritmo “Lowest Candidates”. Fuente: Propia 3.6 Algoritmo de “Crop Candidate” El algoritmo "Crop Candidate" se refiere a la técnica de recortar o extraer una región específica de una imagen, centrada en el candidato seleccionado como el "Lowest Candidate". Técnicamente, después de aplicar el algoritmo "Lowest Candidate" para elegir un candidato en función de ciertas propiedades, se recorta una región alrededor de ese candidato en la imagen original. Este proceso de recorte implica tomar la región rectangular que rodea al "Lowest Candidate" y extraer solo esa porción de la imagen original. Esto tiene el efecto de aislar el objeto o la característica que cumple con los criterios específicos, lo que puede ser útil para análisis posteriores o para visualización enfocada. Por ejemplo, si se ha seleccionado el objeto de menor tamaño utilizando el algoritmo "Lowest Candidate" y se necesita una vista más cercana de ese objeto, puedes aplicar el algoritmo "Crop Candidate" para recortar una región que rodea ese objeto y obtener una imagen ampliada y centrada en él. Esta técnica es valiosa cuando se desea obtener más detalles sobre un objeto o característica específica identificada en la 25 imagen. Puede usarse en aplicaciones donde se requiere una inspección más cercana o cuando se necesita resaltar ciertos aspectos para un análisis detallado. El algoritmo "Crop Candidate" es una técnica que implica recortar una región de la imagen original alrededor del candidato seleccionado (ver Ilustración 14 ROI extraida con algoritmo de “Crop Candidate”. Fuente: Propia) utilizando el algoritmo "Lowest Candidate". Esto permite enfocarse en el objeto de interés, aislando y resaltando la región específica. Ilustración 14 ROI extraida con algoritmo de “Crop Candidate”. Fuente: Propia 3.7 Algoritmo de Adaptative Threshold El algoritmo de umbralización adaptativa (OpenCV Thresholding, s.f.), conocido como algoritmo Adaptative Threshold, es una técnica de procesamiento de imágenes que se utiliza para segmentar una imagen en áreas de interés basadas en niveles de intensidad de píxeles, considerando la variación local en lugar de aplicar un umbral global. Técnicamente, este algoritmo ajusta automáticamente los umbrales según las características locales de la imagen. En lugar de utilizar un único valor umbral para toda la imagen, el algoritmo de umbralización adaptativa divide la imagen en regiones más pequeñas y calcula umbrales específicos para cada región (ver Ilustración 15 ROI con algoritmo de “Adaptative Threshold”. Fuente: Propia). Esto es particularmente útil en imágenes con variaciones de iluminación, donde un umbral global no sería efectivo. El proceso de umbralización adaptativa implica definir un tamaño de ventana o vecindario en el que se calculará el umbral local. El umbral se calcula a partir de los 26 valores de intensidad en la ventana, y luego se aplica a los píxeles en esa región. Este enfoque permite adaptarse a cambios en la iluminación y detalles locales en la imagen. El algoritmo de umbralización adaptativa es una técnica valiosa en el procesamiento de imágenes para segmentar regiones de interés en función de umbrales locales, lo que mejora la precisión en condiciones de iluminación variables. Ilustración 15 ROI con algoritmo de “Adaptative Threshold”. Fuente: Propia 3.8 Algoritmo de Clear Border El algoritmo “Clear Border” se refiere a una técnica combinada en el procesamiento de imágenes. Primero, se aplica el algoritmo "Adaptive Threshold" a la región recortada obtenida con el algoritmo "Crop Candidate". Luego, se aplica el algoritmo "Clear Border" para eliminar cualquier contenido no deseado o irrelevante presente en los bordes de la región resultante después de la umbralización adaptativa. El proceso de "Adaptive Threshold" implica aplicar un umbral adaptativo a la región recortada. A diferencia de un umbral global, el umbral adaptativo calcula umbrales locales en función de las características de intensidad en las vecindades de los píxeles, esto es útil para lidiar con variaciones locales en la iluminación. Luego de aplicar "Adaptive Threshold", algunos bordes no deseados o elementos indeseados pueden persistir en los bordes de la región umbralizada. Es aquí donde entra en juego el algoritmo "Clear Border", que se utiliza para eliminar esa información no relevante en los bordes. Esta técnica combinada es beneficiosa cuando se busca eliminar detalles no deseados y mejorar la calidad de la región recortada y umbralizada. 27 Es útil en situaciones donde el contenido no deseado, como ruido o partes de fondo, puede ser resaltado por el proceso de umbralización adaptativa. El algoritmo "Clear Border" es una técnica que implica aplicar primero un umbral adaptativo a la región recortada y luego eliminar información no deseada en los bordes de la región umbralizada (ver Ilustración 16 ROI Umbralizada con algoritmo de “Clear Border” invertido. Fuente: Propia). Esto permite obtener una región enfocada y libre de detalles irrelevantes para un análisis más preciso y claro. Ilustración 16 ROI Umbralizada con algoritmo de “Clear Border” invertido. Fuente: Propia Capítulo 4 - Desarrollo del Proyecto En este capítulo se presentan los resultados obtenidos con base en los nodos de software y hardware presentadas anteriormente, en donde se reflejarán las soluciones aprovechadas y desarrolladas para cumplir con los objetivos trazados en el proyecto. Como punto inicial, se detallará un diagrama conceptual del proceso esperado en cada uno de los momentos del proceso y así mismo el desenlace con los elementos de hardware y software que participan en cada una de las fases del esquema funcional. En segundo lugar, veremos las variantes, limitaciones y adaptaciones para realizar la identificación OCR con las fotos existentes en la compañía y con el nodo ESP32 CAM, para de esta forma determinar posteriormente sí es una solución viable. Por último, veremos reflejados los resultados frente al proceso de predicción de daños en la flota de vehículos y su integración con el proceso existente. 28 4.1 Esquema Funcional del Proceso A continuación, se detalla el esquema funcional esperado para el cumplimiento de los objetivos del proyecto (ver Ilustración 17 Esquema funcional de la solución IOT. Fuente: Propia). Se plantea una solución integral que sea escalable y que satisfaga las necesidades existentes en el proceso. Esta incluye toda la interacción de los nodos de software y hardware que permiten individualmente cumplir con cada una de sus tareas, pero que al final sumándolas se obtiene una solución integral. Ilustración 17 Esquema funcional de la solución IOT. Fuente: Propia 4.2 Servidor Web ESP32 CAM El nodo ESP32 CAM en este caso al ser parte de la solución integral, debe permitir hacer uso de sus capacidades por medio de un protocolo de comunicación que permita ejecutar las acciones de los sensores que tiene incorporado, en este caso la opción de capturar imágenes gracias al sensor OV2640. Por sí solo, este nodo es capaz de realizar estas acciones (con un firmware programado para estos fines). Sin embargo, es necesario que bajo demanda se puedan realizar estas tareas. Para esto se flasheo un código oficial del fabricante Espressif (ver Ilustración 18 Firmware de Espressif Web Server ESP32 CAM. Fuente: Propia) para el IDE Arduino que está en el repositorio https://github.com/espressif/arduino- esp32/tree/master/libraries/ESP32/examples/Camera/CameraWebServer y que ejecuta un servidor web con las opciones necesarias para capturar video, fotos y configurar 29 algunas características del nodo, de tal forma que posteriormente se procedió a estudiar la estructura de peticiones y respuestas al nodo, para luego aprovecharlas y hacer uso de estas por medio de peticiones bajo el protocolo HTTP. Ilustración 18 Firmware de Espressif Web Server ESP32 CAM. Fuente: Propia Con este firmware se obtiene un servidor web en donde se pueden configurar por medio de una aplicación web (ver Ilustración 19 Aplicación Web Server ESP32 CAM. Fuente: Propia). una serie de características en relación con el funcionamiento de su cámara y las opciones de captura de fotos e incluso videos. 30 Ilustración 19 Aplicación Web Server ESP32 CAM. Fuente: Propia Entre las opciones de mayor interés tenemos la de tomar fotos (ver Ilustración 20 Captura de foto desde Web Server ESP32 CAM. Fuente: Propia), que es la opción que hemos aprovechado para uno de los objetivos del proyecto. Ilustración 20 Captura de foto desde Web Server ESP32 CAM. Fuente: Propia El llamado a la acción de capturar una imagen desde el sensor OV2640 por medio de una aplicación web que está basada en el protocolo HTTP, debe tener como origen 31 una petición y es esta la que se debe monitorear para tratar de invocarla desde un cliente o servidor donde se requiera. Es decir, fue necesario monitorizar que esta petición se realiza a una URI por método GET, denominada capture que retorna una imagen nombrada con un timestamp (ver Ilustración 21 Petición de Captura de foto desde Web Server ESP32 CAM. Fuente: Propia). y que usaremos posteriormente desde otro de los nodos de software. Ilustración 21 Petición de Captura de foto desde Web Server ESP32 CAM. Fuente: Propia La petición realizada al endpoint se puede monitorizar desde la consola de debug (ver Ilustración 22 Estructura de la petición HTTP al Web Server ESP32 CAM. Fuente: Propia) del navegador para ver toda su estructura. Ilustración 22 Estructura de la petición HTTP al Web Server ESP32 CAM. Fuente: Propia 32 4.3 Servidor Web OCR El proceso de identificación de texto basado en imágenes denominado OCR, es el nodo de software que debe encargarse de realizar todo lo inherente al procesamiento de imágenes para su posterior predicción de texto, tomando como argumento la imagen más limpia, con el menor ruido posible y en las mejores condiciones para facilitar su lectura. Este fue desarrollado en Python y aunque en sus primeras versiones su ejecución se encontraba limitado a un contexto de escritorio, se agregó lo necesario para que toda su funcionalidad se comporte como acciones de un endpoint bajo el protocolo HTTP. Esto se logró haciendo uso de Flask Framework (ver Ilustración 23 OCR Servidor Web, código bloque configuración. Fuente: Propia). para exponer cada una de estas con una URI específica y tiene dos versiones para realizar las lecturas de matrículas. Una de ellas tomando las fotos que se ofertan desde las cámaras de la compañía y otra para las fotos tomadas desde el ESP32 CAM. Ilustración 23 OCR Servidor Web, código bloque configuración. Fuente: Propia 33 En este bloque se define una acción denominada “/picture” que realizará una petición al ESP32 CAM Web Server para tomar una foto (ver Ilustración 24 OCR Servidor Web, código bloque captura de foto. Fuente: Propia), posteriormente esta será guardada en un directorio para realizar el tratamiento de la imagen. Ilustración 24 OCR Servidor Web, código bloque captura de foto. Fuente: Propia En este bloque se define una acción denominada “/picture” que realizará una petición al ESP32 CAM Web Server para tomar una foto (ver Ilustración 25 OCR Server, código bloque tratamiento de imagen. Fuente: Propia), posteriormente esta será guardada en un directorio para realizar el tratamiento de la imagen. 34 Ilustración 25 OCR Server, código bloque tratamiento de imagen. Fuente: Propia 4.3.1 Secuencia de Servidor Web OCR con ESP32 CAM En el servidor web de OCR se tiene una secuencia para llevar a cabo la lectura de una de las matrículas de vehículos junto al servidor web de ESP32 CAM. Esta consiste en primer lugar realizar una petición para que el nodo ESP32 CAM tome una foto del vehículo basado en una petición desde el servidor OCR, posteriormente llevarla a un directorio, encontrar la zona de interés basado en la posición, aplicar el tratamiento a la imagen y finalmente realizar su lectura. Esto se puede ver reflejado detalladamente en la ejecución del algoritmo desarrollado para este fin (ver Ilustración 26 Captura de imagen con petición a ESP32 CAM Web Server. Fuente: Propia), así: Ilustración 26 Captura de imagen con petición a ESP32 CAM Web Server. Fuente: Propia La región de interés en encontrada respecto a la posición relativa de las dimensiones definidas por el fabricante y cortada (ver Ilustración 27 Identificación de ROI en la imagen. Fuente: Propia). Ilustración 27 Identificación de ROI en la imagen. Fuente: Propia 35 Una vez identificada la ROI, se procede a binarizar la imagen (ver Ilustración 28 Binarización de la ROI. Fuente: Propia) haciendo uso del algoritmo de Threshold. Ilustración 28 Binarización de la ROI. Fuente: Propia Una vez binarizada la ROI, se procede a limpiar los bordes de la imagen (ver Ilustración 29 Reducción de ruido en bordes. Fuente: Propia) haciendo uso del algoritmo de Clear Borders. Ilustración 29 Reducción de ruido en bordes. Fuente: Propia Una vez depurada la ROI en sus bordes, se procede a invertir la imagen (ver Ilustración 30 Inversión de la imagen y lectura. Fuente: Propia). Ilustración 30 Inversión de la imagen y lectura. Fuente: Propia 36 Una vez la imagen se encuentra invertida, está preparada para entregar al OCR para obtener el texto como resultado (ver Ilustración 31 Petición realizada desde un navegador al endpoint. Fuente: Propia). Ilustración 31 Petición realizada desde un navegador al endpoint. Fuente: Propia 4.4 Cliente HTTP ESP32 con Sensor Sharp El desencadenador de eventos en principio será un cliente HTTP que estará sobre un ESP32 que tiene un firmware que se encarga de conectarse a una red Wifi, y posteriormente iniciar la verificación de proximidad de un objeto, que en nuestro caso será el vehículo. De tal forma que cuando este se encuentre como mínimo a una distancia específica (ver Ilustración 32 Montaje de HTTP Cliente en ESP32. Fuente: Propia), que es tomada por el sensor Sharp, se iniciará una petición al servidor OCR Web Server. El servidor OCR Web Server al recibir la petición por parte de este cliente HTTP, realizará a su vez la petición al ESP32 CAM Web Server para la captura de la imagen, misma que recibirá el servidor de OCR y que tratará con los algoritmos previamente vistos, para por último realizar la lectura del texto y enviarla en una respuesta. 37 Ilustración 32 Montaje de HTTP Cliente en ESP32. Fuente: Propia 4.4.1 Firmware del Cliente HTTP Este firmware se encarga de verificar continuamente sí existe un objeto a una distancia “x” frente al sensor Sharp, y sí esto se cumple entonces desencadena todas las acciones mencionadas anteriormente. Para esto fue necesario desarrollar un firmware que responda a esta necesidad funcional, para ello se destacan las partes más importantes del código para solucionar este problema. En esta parte podemos apreciar que se define principalmente el GPIO en donde se van a recibir las medidas tomadas por el sensor Sharp, el GPIO para el LED que va a indicar que el umbral de distancia se ha superado (ver Ilustración 33 Cliente HTTP ESP32, código bloque de configuración. Fuente: Propia) y por supuesto el umbral de distancia definido 38 para ello, adicionalmente el endpoint donde se enviarán las peticiones y que este corresponde al OCR Web Server. Ilustración 33 Cliente HTTP ESP32, código bloque de configuración. Fuente: Propia Una vez se definen las configuraciones para el cliente HTTP, en este se deben controlar los llamados al servidor de acuerdo al momento en que se supere el umbral definido anteriormente y cuando esto ocurra, se realizará una petición al endpoint y se encenderá una LED en color verde. Es por esto que en el siguiente bloque de código (ver Ilustración 34 Cliente HTTP ESP32, código bloque de verificación. Fuente: Propia) encontraremos las verificaciones de sí se supera este umbral, la peticiones realizada y la forma en que se gestiona la respuesta. 39 Ilustración 34 Cliente HTTP ESP32, código bloque de verificación. Fuente: Propia Una vez teniendo este cliente configurado, lo que resta para comprobar su funcionamiento es garantizar que el servidor OCR Web Server se encuentre en escucha (ver Ilustración 35 Verificación OCR Web Server Disponible. Fuente: Propia), para que así el cliente HTTP del ESP32 pueda hacer una petición con un estatus de respuesta correcto. Ilustración 35 Verificación OCR Web Server Disponible. Fuente: Propia 40 Lo primero que se verificará es que las lecturas realizadas por el sensor Sharp no sean superiores al umbral (ver Ilustración 36 Cliente HTTP ESP32, Lectura del puerto serial. Fuente: Propia) y no se desencadenen las acciones para el llamado al endpoint. Ilustración 36 Cliente HTTP ESP32, Lectura del puerto serial. Fuente: Propia En casos donde las lecturas superen el umbral definido en la configuración, se indicará una salida de luz en color verde en el LED, de tal forma que se sepa el momento en que la distancia ha superado dicho umbral. Cuando esto ocurra, entonces se llamará al endpoint para que inicie su proceso de captura de foto, procesamiento y lectura de texto devuelto en una respuesta al cliente. Será el cliente HTTP quien se encargue de con esta respuesta realizar las demás tareas (ver Ilustración 37 Cliente HTTP ESP32, Indicador LED. Fuente: Propia) que sean necesarias para el proceso. 41 Esta respuesta como se indicó anteriormente, también puede ser solicitada por un navegador, que actúa en este caso como otro cliente HTTP. Ilustración 37 Cliente HTTP ESP32, Indicador LED. Fuente: Propia En cuanto esto ocurra y se llame al endpoint, se obtendrá la respuesta por medio del puerto serial (ver Ilustración 38 Cliente HTTP ESP32, Llamado a endpoint. Fuente: Propia). 42 Ilustración 38 Cliente HTTP ESP32, Llamado a endpoint. Fuente: Propia 4.5 OCR Server con Cámara de la Empresa Aunque en el capítulo del estado de la cuestión se puede percibir a groso modo el proceso de lectura de texto a partir de imagen, es importante resaltar que el tratamiento que se da en este caso es un poco diferente al que se realiza cuando se capturan las fotos con el ESP32 CAM. Es decir, estas fotos son tomadas por cámaras que se encuentran instaladas en la compañía, pero que no tienen como finalidad el reconocimiento de las matrículas, sino que simplemente se usan para dejar constancia de las entradas y salidas de los vehículos de una forma no automatizada, sino que son controladas por empleados. En este proceso de tratamiento de imágenes, lo que se pretende es encontrar la zona de interés y eliminar todo el ruido posible para su posterior lectura. Esto se realiza con los algoritmos descritos anteriormente, pero que básicamente tienen la siguiente secuencia:  Se toma la imagen original  Se aplica algoritmo de escala de grises  Se aplica algoritmo para binarización general  Se aplica algoritmo de binarización adaptativa  Se aplica algoritmo de búsqueda de contornos  Se aplica algoritmo para filtrar candidatos  Se aplica algoritmo para obtener el candidato en la posición menor  Se aplica algoritmo para limpiar ruido de bordes y de “resize”  Se aplica algoritmo para Invertir imagen  Se entrega la imagen final al algoritmo de lectura Esta secuencia de algoritmos específicos, permiten de forma integral que se pueda obtener una imagen final de la zona de interés de la imagen general, que se encuentre libre del mayor ruido posible y con unas condiciones idóneas para entregarla al proceso de reconocimiento de texto a base de imágenes, en nuestro caso el OCR Cam Company. 43 A continuación, se muestran los resultados de cada uno de estos algoritmos en la línea de secuencia sobre la imagen, de tal forma que se puedan apreciar los cambios que sufre la imagen por cada uno de estos hasta llegar al proceso final de lectura (ver Ilustración 39 Orden de ejecución de algoritmos en Python para OCR. Fuente: Propia). Ilustración 39 Orden de ejecución de algoritmos en Python para OCR. Fuente: Propia Inicio del proceso de OCR sobre la imagen original de un vehículo en la base de operaciones, que es una imagen originalmente tomada por una de las camaras de la compañía (ver Ilustración 40 Vehículo compactador original en base de operaciones. Fuente: Propia). Ilustración 40 Vehículo compactador original en base de operaciones. Fuente: Propia 44 A la imagen original del vehículo en la base de operaciones, se le aplica en primera medida el algoritmo de GrayScale para anular los tres canales de color y dejar exclusivamente dos (ver Ilustración 41 Vehículo compactador con algoritmo GrayScale. Fuente: Propia). Ilustración 41 Vehículo compactador con algoritmo GrayScale. Fuente: Propia En estos momentos del proceso, la imagen se encuentra en escala de grises, lo que permite aplicar un algoritmo de binarización, dado que únicamente existen dos canales de color (blanco y negro) que, de acuerdo a su intensidad, este algoritmo será capaz de determinar un umbral para posteriormente decidir entre los dos valores a asignar en cada pixel (ver Ilustración 42 Vehículo con algoritmo de binarización. Fuente: Propia). Ilustración 42 Vehículo con algoritmo de binarización. Fuente: Propia En el momento que la imagen ya se encuentra binarizada, es posible someterla al algoritmo de búsqueda de contornos (ver Ilustración 43 Vehículo compactador con algoritmo de contornos. Fuente: Propia). y la búsqueda de candidatos. 45 Ilustración 43 Vehículo compactador con algoritmo de contornos. Fuente: Propia A la imagen de contornos del vehículo en la base de operaciones, se le aplica el algoritmo de Filter Candidates para excluir los contornos que no sean parecidos a una figura rectangular (ver Ilustración 44 Resultado de algoritmo de candidatos. Fuente: Propia) y que tengan una relación de aspecto idóneo. Ilustración 44 Resultado de algoritmo de candidatos. Fuente: Propia Una vez se tiene identificada la región de interés (ROI) es posible aplicar el algoritmo de corte (ver Ilustración 45 Imagen con algoritmo de corte en ROI. Fuente: Propia) y ampliación de la región de interés. Ilustración 45 Imagen con algoritmo de corte en ROI. Fuente: Propia Al tener identificada la región de interés, se procede a aplicar el algoritmo de binarización (ver Ilustración 46 ROI con algoritmo de binarización. Fuente: Propia) y de eliminación de ruido en los bordes. 46 Ilustración 46 ROI con algoritmo de binarización. Fuente: Propia Una vez binarizada la ROI, se aplica el algoritmo para realizar la limpieza en sus bordes (ver Ilustración 47 ROI con algoritmo limpieza de bordes. Fuente: Propia). Ilustración 47 ROI con algoritmo limpieza de bordes. Fuente: Propia Una vez limpiados los bordes, es posible invertir la imagen para dar mayor claridad a los caracteres (ver Ilustración 48 Imagen con algoritmo de inversión de imagen. Fuente: Propia). Ilustración 48 Imagen con algoritmo de inversión de imagen. Fuente: Propia 4.6 Predicción de Daños con Mask R-CNN El proceso para entrenar un algoritmo de detección de daños utilizando Mask R- CNN (Mask Region-based Convolutional Neural Network) es un procedimiento técnico que implica varias etapas clave. A continuación, se describen las etapas de manera generalizada y que se encuentran basadas en el repositorio https://github.com/louisyuzhe/car-damage-detector dado que como limitante, la compañía PROMOMABIENTAL por el momento se encuentra en la construcción de un https://github.com/louisyuzhe/car-damage-detector 47 Dataset. Sin embargo, este proceso se realizó en paralelo con uno existente; de tal forma que se pudiese entender el contexto general de una solución como esta, para posteriormente implementarla con el nuevo conjunto de datos.  Recopilación de datos etiquetados Se reúne un conjunto de datos que contenga imágenes que muestren daños, así como etiquetas que indiquen la ubicación y la naturaleza de los daños en cada imagen (ver Ilustración 49 Etiquetado de Imágenes. Fuente: Propia). Estas etiquetas suelen estar en formato de máscara de segmentación (mask), que muestra qué píxeles corresponden a los objetos dañados. Ilustración 49 Etiquetado de Imágenes. Fuente: Propia  Preprocesamiento de datos Para esto fue necesario asegurarse de que las imágenes están en un formato adecuado y sean del mismo tamaño. Normalmente, se escalan y se ajustan para que todas tengan dimensiones uniformes y así garantizar homogeneidad sobre estas características en el proceso de entrenamiento del modelo. 48  División del conjunto de datos Se dividió el conjunto de datos en dos partes: entrenamiento y validación. El conjunto de entrenamiento se utiliza para entrenar el modelo, el conjunto de validación se utiliza para ajustar los hiperparámetros, evaluar el rendimiento durante el entrenamiento (ver Ilustración 50 Subconjuntos de datos. Fuente: Github Louisyuzhe), y el para evaluar el modelo final. Ilustración 50 Subconjuntos de datos. Fuente: Github Louisyuzhe  Configuración del modelo Mask R-CNN Se configuró la arquitectura del modelo Mask R-CNN. Esto incluye la elección de una red base (como ResNet o MobileNet), la capa de encabezado de regresión para la detección de objetos y la capa de encabezado de segmentación para generar máscaras de segmentación.  Transferencia de aprendizaje Se inicializó el modelo con pesos preentrenados en un conjunto de datos grande (como ImageNet o CoCo) para acelerar el entrenamiento y mejorar la capacidad de generalización.  Entrenamiento del modelo Se utilizó el conjunto de entrenamiento para entrenar el modelo. Durante el entrenamiento, se ajustan los pesos del modelo para que se ajusten a los datos del 49 conjunto de datos específico. Se utiliza una función de pérdida que mide la discrepancia entre las predicciones del modelo y las etiquetas reales.  Validación y ajuste de hiperparámetros Se Utilizó el conjunto de validación para ajustar hiperparámetros como la tasa de aprendizaje y la cantidad de épocas de entrenamiento. El objetivo es mejorar el rendimiento del modelo en el conjunto de validación.  Evaluación del modelo Finalmente, se utilizó el conjunto de prueba para evaluar el rendimiento del modelo entrenado. Esto incluye métricas como la precisión, el recuerdo, la F1-score y la IoU (Intersección sobre Unión) para evaluar la detección y la segmentación de daños (ver Ilustración 51 Evaluación del modelo. Fuente: Github Louisyuzhe). Ilustración 51 Evaluación del modelo. Fuente: Github Louisyuzhe  Ajustes finales y despliegue Se realizaron ajustes finales según los resultados de la evaluación. Una vez satisfecho con el rendimiento, se pudo desplegar el modelo entrenado para la detección de daños en un entorno controlado (ver Ilustración 52 Despliegue del modelo. Fuente: Github Louisyuzhe). 50 Ilustración 52 Despliegue del modelo. Fuente: Github Louisyuzhe 51 Capítulo 5 - Conclusiones y trabajo futuro En este capítulo presentaremos las conclusiones del trabajo y líneas de trabajo futuro. 5.1 Conclusiones Las conclusiones generadas a partir de la realización de este trabajo, desde una óptica general hasta llegar a las más específicas, son las siguientes. En primer lugar, es imperante mencionar que el nodo ESP32 CAM con su ecosistema de software y hardware, es sin duda un nodo muy versátil para diferentes situaciones donde se requiera el uso de cámaras de no tan altas prestaciones, de bajo coste y la conectividad Wifi o Bluetooth, de tal forma que pueda ser explotado con todas sus características que se adaptan totalmente a una solución IoT. En segundo lugar, el ESP32 CAM por sí sólo no ofrece grandes funcionalidades para poder extraer la información de las fotografías que captura, pues se limita a su almacenamiento en la unidad de almacenamiento. Sin embargo, al desplegarlo como un servidor HTTP, la funcionalidad de su cámara puede llegar a ser usada con mayor facilidad evitando temas de almacenamiento reducido o la complejidad para extraerlas del mismo nodo. Desde un punto de vista más específico, hemos podido comprobar que es posible realizar procesos de reconocimiento de texto en imágenes aún con cámaras de bajas prestaciones. Que, aunque estas no sean las más idóneas para temas como este, sí ofrecen posibilidades interesantes para llevar a cabo tareas de este tipo; de tal forma que se combinen con técnicas de procesamiento de imágenes para lograr su cometido y poder tener resultados precisos. También hemos desarrollado un mecanismo que, con base en los valores leídos de proximidad de un objeto, activa un cliente HTTP desde un ESP32. Aprovechando así la versatilidad que tiene este nodo para incorporarlo en el desarrollo de la solución IoT que planteamos. 52 También hemos aprovechado la potencia del lenguaje de programación Python para casi todos los componentes de software del entorno de la solución (exceptuando el firmware de los SoC), permitiendo así que cada uno de estos se pudiese comportar como parte de un protocolo de comunicación, en nuestro caso HTTP, pues todas las funcionalidades se pueden gestionar bajo este. También hemos incursionado en otras líneas de la informática, como es el caso de la IA para el reconocimiento de daños en vehículos por medio de Mask-R CNN. Que podemos afirmar que estas requieren unos recursos computacionales que no son tan coherentes con las restricciones que comúnmente tienen los despliegues IoT. Sin embargo, es preciso aclarar que todo dependerá del contexto en cuanto a las limitaciones o recursos para el despliegue de una solución IoT. Finalmente, por lo que se refiere a la solución integral, que involucra componentes de hardware y software, podemos afirmar que, de acuerdo a la arquitectura planteada, es una solución escalable y que sin duda puede ser aprovechada para los objetivos planteados. 5.2 Trabajo Futuro Uno de los grandes retos y limitantes que se encontró en el desarrollo de este trabajo, es el de tener la información suficiente para poder crear un modelo de aprendizaje totalmente apto para el reconocimiento de los daños en los vehículos de la compañía. Dado que, por razones ajenas a lo técnico, esta información por el momento se encuentra en construcción. Esto concluye que es fundamental la construcción de un Dataset que permita realizar el desarrollo de un modelo que responda a las necesidades de la compañía. Consecuentemente, es necesario que cuando se haya desarrollado un modelo que responde a las necesidades de la empresa, este componente de software debe ser adherido como un servicio web para poder garantizar su funcionalidad dentro del protocolo de comunicación en que funciona el despliegue IoT. Finalmente será necesario el desarrollo de un Dashboard que permita visualizar históricamente las estadísticas de daños, los registros diarios de daños y toda la inteligencia de negocios que pueden ofertar los datos relacionados al proceso. 53 Capítulo 6 - Introduction In the search for continuous improvement, time optimization and best practices, technology represents the means through which solutions that provide agility, focus and accuracy are enhanced, allowing the business and people to spend time on activities that provide greater value (core business). This is the reason why the identification of repetitive activities and the search for efficiency propitiate the use of technologies such as IOT systems, thus guaranteeing less time spent on mechanical activities. Technological progress in certain fields has made it possible to pluralize the technologies that can be used to serve different areas of companies and thus create heterogeneous solution environments that serve processes that were unthinkable a few years ago. This is the case of computer vision, which is currently one of the most striking fields to meet many needs in companies. In general, the processes that are the object of study for automation are those that have a greater impact on factors such as: time dedication, risk and costs in its execution. PROMOAMBIENTAL Holding is a company dedicated to the urban sanitation service that has coverage in multiple departments of Colombia and is monitored by regulatory institutions, having as one of its requirements that the fleet of its vehicles is in the best physical conditions to ensure the safety of employees and provide support in the districts where they provide their services, since this activity is regulated under a regulatory and contractual framework. This company has the obligation to maintain the vehicle fleet in the best conditions, so it has an area dedicated to manage the entire life cycle of the vehicle. Therefore, if a vehicle is damaged or malfunctions in identified areas of interest, it will undergo a recovery process until the damage is repaired. This process is fundamental and evidences the need for the development of an IOT system. Currently, there are damages that are not identified in a timely manner, which represents non-compliance, penalties and a time commitment by employees that, although high, does not guarantee efficiency. 54 6.1 Motivation The company PROMOAMBIENTAL located in the city of Bogota D.C., Colombia, currently performs the provision of public sanitation services in one of the largest areas of the city. This company has a fleet of more than one hundred vehicles for its daily operation. This fleet must be maintained in optimal conditions to provide the service, so it is necessary to monitor it daily to ensure that it does not present damages that could affect the performance of these tasks. For this reason, the company has a series of cameras that record the condition of the vehicles at the time of entry and exit, so that an operator can later capture the license plate data and possible damages, and finally deposit them in a series of Excel spreadsheets. This situation has two issues that become necessities to ensure an efficient solution. One of these, is to have the ability to identify each of the vehicles based on their license plate; but with the cameras that the company has, not having any kind of connectivity, it is a restriction. So the idea was born to do it with an ESP32CAM which is a low cost IoT node with Wifi and Bluetooth interfaces, it also has a camera that can be connected as a peripheral. And although the pictures taken with this will not be of great quality, this is a very interesting challenge for the case study. There is also the need to identify in a timely manner the most common damages that occur in the vehicle fleet. At the moment, the area of interest is the front axle of these vehicles, which is where the highest impact damages are concentrated. Therefore, in this work, the aim is to develop an IOT solution that solves the problem of efficiency in the identification of vehicles entering and/or leaving the base of operations and the damages they suffer according to their daily operation. Prioritizing the lowest possible cost for its development and ensuring that the architecture of the solution is scalable for the future. 55 6.2 Objetives The following is a description of the objectives pursued with the development of this work. Firstly, it is intended to develop an image capture server in the ESP32CAM device that can be managed by a standard communication protocol, so that it can be a node in the architecture of the solution. Consequently, to the first objective, the images taken by this node will have to be sent to a license plate identification node. Therefore, it will be necessary to develop software (OCR) that allows the identification of text based on images. In addition, it is intended that the photos captured by the company's cameras, intended for fault detection, will be sent to a node specialized in identifying damage. This node will confirm whether there is damage in the areas of interest. Therefore, it is necessary to create software that, based on an image, can determine whether there is damage. This will be achieved by using convolutional neural networks (CNN) in combination with existing algorithms. 6.3 Workplan The work plan to be carried out in order to meet the proposed objectives begins by approaching the process of image processing and deep learning in this context, in order to adopt the necessary knowledge to make use of this technology and thus apply it in the situations required by this project. In order to achieve this knowledge, it will be necessary to investigate the most suitable techniques, modes of operation, advantages and limitations that could be of use for the development of the proposed solution. Subsequently, it will be necessary to study the technical aspects of the ESP32CAM chip both in its software and hardware components. The main focus will be to understand the capabilities offered by its camera, since this will be fundamental in the identification process. In such a way that according to these characteristics and the different experiments carried out in terms of distances, illumination and other factors, it will be possible to determine an ideal identification scenario. Once the essential characteristics of the ESP32CAM device are known, the appropriate development environment will be selected to load the Firmware in the device. This 56 firmware will be responsible for capturing images of the vehicles for identification, and will be developed with the necessary functionalities. Simultaneously, the image-based text recognition node will be developed. This node will process the images captured by the ESP32CAM device and perform the prediction of the text present in them. An algorithm that can be trained with a customizable dataset will also be developed, which will be in charge of identifying the damage in the vehicle fleet and notifying it through a specific communication protocol. 57 Capítulo 7 - Conclusions and Future Work This chapter recaps the main conclusions and also the potential lines of future work. 7.1 Conclusions The conclusions generated from this work, from a general point of view to the more specific ones, are the following. Firstly, it is imperative to mention that the ESP32 CAM node with its software and hardware ecosystem, is undoubtedly a very versatile node for different situations where the use of cameras of not so high performance, low cost and Wifi or Bluetooth connectivity is required, so that it can be exploited with all its features that are fully adapted to an IoT solution. Secondly, the ESP32 CAM by itself does not offer great functionalities to be able to extract information from the pictures it captures, as it is limited to its storage in the storage unit. However, by deploying it as an HTTP server, its camera functionality can become more easily usable avoiding issues of reduced storage or the complexity to extract them from the same node. From a more specific point of view, we have been able to verify that it is possible to perform text recognition processes on images even with low performance cameras. Although these are not the most suitable for topics like this, they do offer interesting possibilities to carry out tasks of this type; in such a way that they are combined with image processing techniques to achieve their purpose and to be able to have accurate results. We have also developed a mechanism that, based on the proximity values read from an object, activates an HTTP client from an ESP32. Thus taking advantage of the versatility of this node to incorporate it in the development of the IoT solution we propose. We have also taken advantage of the power of the Python programming language for almost all the software components of the solution environment (except for the firmware of the SoCs), thus allowing each of these to behave as part of a communication protocol, in our case HTTP, since all the functionalities can be managed under it. 58 We have also ventured into other lines of computing, as is the case of AI for vehicle damage recognition by means of Mask-R CNN. That we can state that these require computational resources that are not so consistent with the constraints that IoT deployments commonly have. However, it should be clarified that everything will depend on the context in terms of constraints or resources for the deployment of an IoT solution. Finally, with regard to the integral solution, which involves hardware and software components, we can affirm that, according to the proposed architecture, it is a scalable solution that can undoubtedly be used for the proposed objectives. 7.2 Future Work One of the great challenges and limitations encountered in the development of this work is to have enough information to be able to create a learning model fully suitable for the recognition of damage in the company's vehicles. Given that, for non- technical reasons, this information is currently under construction. This concludes that it is essential to build a Dataset that allows the development of a model that meets the needs of the company. Consequently, it is necessary that when a model that responds to the needs of the company has been developed, this software component must be attached as a web service in order to guarantee its functionality within the communication protocol in which the IoT deployment works. Finally, it will be necessary to develop a Dashboard that allows the historical visualization of damage statistics, daily damage records and all the business intelligence that the data related to the process can offer. 59 BIBLIOGRAFÍA [1] Espressif, I. Espressif. https://www.espressif.com, 2023. [2] Abekiri, N., Rachdy, A., Ajaamoum, M., Nassiri, B., Elmahni, L., & Oubail, Y. (2023). Platform for hands-on remote labs based on the ESP32 and NOD-red. Scientific African, 19(e01502), e01502. https://doi.org/10.1016/j.sciaf.2022.e01502. [3] Ashari, I. F., Satria, M. D., & Idris, M. (s/f). Parking system optimization based on IoT using face and vehicle plat recognition via Amazon web service and ESP-32 CAM. Unsri.ac.id. Recuperado el 3 de septiembre de 2023, de https://comengapp.unsri.ac.id/index.php/comengapp/article/download/409/251 [4] Abdellatif, M. M., Elshabasy, N. H., Elashmawy, A. E., & AbdelRaheem, M. (2023). A low cost IoT-based Arabic license plate recognition model for smart parking systems. Ain Shams Engineering Journal, 14(6), 102178. https://doi.org/10.1016/j.asej.2023.1021781 [5] Wilmoth, P., & Sundaravadivel, P. (2021). An Interactive IoT-based framework for Resource Management in Assisted living during pandemic. 2021 22nd International Symposium on Quality Electronic Design (ISQED), 571–575 [6] AI Thinker, I. AI Thinker. https://docs.ai-thinker.com/en/esp32-cam, 2023 [7] Louiseyuzhe. Louiseyuzhel/car-damage-detector Mask R-CNN for Car Damage Detection and Segmentation. https://github.com/louisyuzhe/car-damage- detector, 2021. [8] Carolin, S., Yanti, S., & Sulistiyowati, I. (s/f). An inventory tool for receiving practicum report based on IoT by using ESP32-CAM and UV sterilizer: A case study at. Umy.ac.id. Recuperado el 6 de septiembre de 2023, de https://journal.umy.ac.id/index.php/jet/article/download/14607/7529 60 [9] Kyu, P. M., & Woraratpanya, K. (2020). Car Damage Detection and Classification. Proceedings of the 11th International Conference on Advances in Information Technology. [10] Dhieb, N., Ghazzai, H., Besbes, H., & Massoud, Y. (2019). A very deep transfer learning model for vehicle damage detection and localization. 2019 31st International Conference on Microelectronics (ICM), 158–161. [11] Siwan, S. J., Shareef, W. F., & Nasser, A. R. (2022). Machine learning in AWS for IoT- based oil pipeline monitoring system. Webology, 19(1), 3169–3183. https://doi.org/10.14704/web/v19i1/web19209. [12] Parkavi, Shaha, K., Rajodiya, P., & Samruddha. (2023). Advanced agricultural management using machine learning and lot. SSRN Electronic Journal. https://doi.org/10.2139/ssrn.4500906. [13] Parkavi, Shaha, K., Rajodiya, P., & Samruddha. (2023). Advanced agricultural management using machine learning and lot. SSRN Electronic Journal. https://doi.org/10.2139/ssrn.4500906. [14] Wi-Fi. G., Bluetooth , Bluetooth, & Soc, L. E. (n.d.). ESP32 Series Datasheet. Espressif.com, https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf [15] ESP32-CAM camera development board (n.d.). Ai-thinker.com. https://docs.ai- thinker.com/en/esp32-cam [16] Esp32-cam ov2640. (n.d.). Einstronic Enterprise. Retrieved September 3, 2023, from https://einstronic.com/product/esp32-cam-ov2640/ [17] General Description. (n.d.). OV2640 Color CMOS UXGA (2.0 Mega Pixel) CAMERACHIPTM with Omni Pixel2TM Technology. Uctronics.com. https://www.uctronics.com/download/cam_module/OV2640DS.pdf [18] Datasheet for GP2Y0A41SK0F Sharp Integrated Circuits (ICs). (n.d.). Octopart. https://octopart.com/datasheet/gp2y0a41sk0f-sharp-42201769 61 [19] Carter, O. (n.d.). esp32-cam-webserver: Expanded version of the Espressif ESP webcam. https://github.com/easytarget/esp32-cam-webserver [20] Fiorino, S. (n.d.). license-plate-recognition: Argentinian License Plate Recognizer. https://github.com/santifiorino/license-plate-recognition [21] Huallpa, E. C., Escuela Profesional de Ingeniería de Sistemas, Universidad Peruana Unión, Macalupu, A. A. S., Luque, J. E. O., Sánchez-Garces, J., Escuela Profesional de Ingeniería de Sistemas, Universidad Peruana Unión, Escuela Profesional de Ingeniería de Sistemas, Universidad Peruana Unión, & Facultad de Ingeniería y Gestión Universidad Nacional Tecnológica de Lima Sur. (2023). Determinación del mejor algoritmo de detección de matrículas en ambientes controlados y no controlados. RISTI - Revista Ibérica de Sistemas e Tecnologias de Informaci, 49(49), 83–99. https://doi.org/10.17013/risti.49.83-99