- Prerrequisitos
- Pasos involucrados en el reconocimiento de matrículas usando Raspberry Pi
- 1. Detección de matrículas
- 2. Segmentación de personajes
- 3. Reconocimiento de caracteres
- Casos fallidos en el reconocimiento de matrículas
- Otros ejemplos exitosos
La seguridad siempre ha sido una de las principales preocupaciones de la humanidad. Hoy tenemos cámaras de videovigilancia en escuelas, hospitales y cualquier otro lugar público para que nos sintamos seguros. Según una encuesta de HIS, se estima que había alrededor de 245 millones de cámaras de seguridad instaladas y funcionando en 2014, lo que es como tener una cámara de seguridad por cada 30 personas en este planeta. Con el avance de la tecnología, especialmente en el procesamiento de imágenes y el aprendizaje automático, es posible hacer que estas cámaras sean más inteligentes capacitándolas para procesar la información de la transmisión de video.
La transmisión de video de estas cámaras se puede utilizar para realizar reconocimiento facial, análisis de patrones, análisis de emociones y mucho más, lo que realmente lo acercaría a algo como el "Ojo de Dios" que se muestra en la película FF7. De hecho, empresas de vigilancia como Hikvision y muchas otras ya han comenzado a implementar estas funciones en sus productos. Anteriormente utilizamos el procesamiento de imágenes de MATLAB para leer la matrícula, hoy en este artículo aprenderemos cómo reconocer y leer el número de matrícula de automóviles usando Raspberry Pi y OpenCV. Usaremos algunas imágenes de vehículos aleatorias de Google y escribiremos un programa para reconocer la matrícula usando OpenCV Contour Detection y luego leeremos el número de la matrícula usando Tesseract OCR. Suena interesante, ¡verdad !, así que comencemos.
Prerrequisitos
Como se dijo anteriormente, usaremos la biblioteca OpenCV para detectar y reconocer rostros. Así que asegúrese de instalar OpenCV Library en Raspberry Pi antes de continuar con este tutorial. También encienda su Pi con un adaptador de 2A y conéctelo a un monitor para facilitar la depuración.
Este tutorial no explica cómo funciona exactamente OpenCV, si está interesado en aprender el procesamiento de imágenes, consulte estos tutoriales básicos de OpenCV y procesamiento de imágenes avanzado. También puede aprender sobre contornos, detección de manchas, etc. en este tutorial de segmentación de imágenes usando OpenCV. Haremos algo similar a esto para detectar la matrícula del coche en la imagen.
Pasos involucrados en el reconocimiento de matrículas usando Raspberry Pi
El reconocimiento de matrículas o LPR para abreviar, implica tres pasos principales. Los pasos son los siguientes
1. Detección de matrícula: el primer paso es detectar la matrícula del automóvil. Usaremos la opción de contorno en OpenCV para detectar objetos rectangulares para encontrar la matrícula. La precisión se puede mejorar si conocemos el tamaño exacto, el color y la ubicación aproximada de la placa de matrícula. Normalmente, el algoritmo de detección se entrena en función de la posición de la cámara y el tipo de matrícula utilizada en ese país en particular. Esto se complica si la imagen ni siquiera tiene coche, en este caso daremos un paso adicional para detectar el coche y luego la matrícula.
2. Segmentación de personajes: Una vez que hemos detectado la matrícula tenemos que recortarla y guardarla como una nueva imagen. Nuevamente, esto se puede hacer fácilmente usando OpenCV.
3. Reconocimiento de caracteres: Ahora, la nueva imagen que obtuvimos en el paso anterior seguramente tendrá algunos caracteres (Números / Alfabetos) escritos en ella. Entonces, podemos realizar OCR (reconocimiento óptico de caracteres) para detectar el número. Ya explicamos el reconocimiento óptico de caracteres (OCR) con Raspberry Pi.
1. Detección de matrículas
El primer paso en este lector de matrículas Raspberry Pi es detectar la matrícula. Tomemos una imagen de muestra de un automóvil y comencemos por detectar la matrícula en ese automóvil. Luego usaremos la misma imagen para la segmentación de caracteres y también para el reconocimiento de caracteres. Si desea saltar directamente al código sin explicación, puede desplazarse hasta la parte inferior de esta página, donde se proporciona el código completo. La imagen de prueba que estoy usando para este tutorial se muestra a continuación.
Paso 1: Cambie el tamaño de la imagen al tamaño requerido y luego escale la escala de grises. El código para el mismo se da a continuación.
img = cv2.resize (img, (620,480)) gray = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) #convertir a escala de grises
Cambiar el tamaño nos ayuda a evitar cualquier problema con imágenes de mayor resolución, asegúrese de que la matrícula aún permanece en el marco después de cambiar el tamaño. La escala de grises es común en todos los pasos de procesamiento de imágenes. Esto acelera otros procesos siguientes, ya que ya no tenemos que ocuparnos de los detalles de color al procesar una imagen. La imagen se transformaría en algo así cuando se realiza este paso
Paso 2: Cada imagen tendrá información útil e inútil, en este caso para nosotros solo la matrícula es la información útil el resto son prácticamente inútiles para nuestro programa. Esta información inútil se llama ruido. Normalmente, el uso de un filtro bilateral (difuminado) eliminará los detalles no deseados de una imagen. El código para el mismo es
gray = cv2.bilateralFilter (gris, 11, 17, 17)
La sintaxis es destination_image = cv2.bilateralFilter (source_image, diámetro del píxel, sigmaColor, sigmaSpace). Puede aumentar el color sigma y el espacio sigma de 17 a valores más altos para difuminar más información de fondo, pero tenga cuidado de que la parte útil no se vuelva borrosa. La imagen de salida se muestra a continuación, como puede ver, los detalles del fondo (árbol y edificio) están borrosos en esta imagen. De esta manera podemos evitar que el programa se concentre en estas regiones más adelante.
Paso 3: El siguiente paso es interesante donde realizamos la detección de bordes. Hay muchas formas de hacerlo, la forma más fácil y popular es usar el método de borde astuto de OpenCV. La línea para hacer lo mismo se muestra a continuación.
edged = cv2.Canny (gray, 30, 200) #Realizar detección de bordes
La sintaxis será imagen_destino = cv2.Canny (imagen_origen, valor umbral 1, valor umbral 2). El valor de umbral 1 y el valor de umbral 2 son los valores de umbral mínimo y máximo. Solo se mostrarán los bordes que tengan un gradiente de intensidad mayor que el valor de umbral mínimo y menor que el valor de umbral máximo. La imagen resultante se muestra a continuación.
Paso 4: Ahora podemos comenzar a buscar contornos en nuestra imagen, ya hemos aprendido cómo encontrar contornos usando OpenCV en nuestro tutorial anterior, así que procedemos de la misma manera.
nts = cv2.findContours (edged.copy (), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours (cnts) cnts = sorted (cnts, key = cv2.contourArea, reverse = True) screenCnt = None
Una vez que se han detectado los contadores, los clasificamos de grandes a pequeños y consideramos solo los primeros 10 resultados ignorando los demás. En nuestra imagen el mostrador podría ser cualquier cosa que tenga una superficie cerrada pero de todos los resultados obtenidos también estará el número de matrícula ya que también es una superficie cerrada.
Para filtrar la imagen de la matrícula entre los resultados obtenidos, recorreremos todos los resultados y comprobaremos cuál tiene un contorno en forma de rectángulo con cuatro lados y una figura cerrada. Dado que una matrícula definitivamente sería una figura rectangular de cuatro lados.
# recorrer nuestros contornos para c en cnts: # aproximar el contorno peri = cv2.arcLength (c, True) approx = cv2.approxPolyDP (c, 0.018 * peri, True) # si nuestro contorno aproximado tiene cuatro puntos, entonces # nosotros podemos asumir que hemos encontrado nuestra pantalla si len (approx) == 4: screenCnt = approx break
El valor 0.018 es un valor experimental; puede probarlo para comprobar cuál funciona mejor para usted. O llévelo al siguiente nivel utilizando el aprendizaje automático para entrenar basándose en imágenes de automóviles y luego use el valor correcto allí. Una vez que hayamos encontrado el contador correcto lo guardamos en una variable llamada screenCnt y luego dibujamos un cuadro rectangular a su alrededor para asegurarnos de que hemos detectado la matrícula correctamente.
Paso 5: Ahora que sabemos dónde está la matrícula, la información restante es prácticamente inútil para nosotros. Entonces podemos proceder a enmascarar toda la imagen excepto el lugar donde está la matrícula. El código para hacer lo mismo se muestra a continuación.
# Enmascarando la parte que no sea la placa de matrícula mask = np.zeros (gray.shape, np.uint8) new_image = cv2.drawContours (mask,, 0,255, -1,) new_image = cv2.bitwise_and (img, img, mask = máscara)
La nueva imagen enmascarada aparecerá algo como a continuación
2. Segmentación de personajes
El siguiente paso en el reconocimiento de matrículas de Raspberry Pi es segmentar la matrícula de la imagen recortándola y guardándola como una nueva imagen. Luego podemos usar esta imagen para detectar el personaje en ella. El código para recortar la imagen de roi (región de interés) de la imagen principal se muestra a continuación
# Ahora recortar (x, y) = np. where (mask == 255) (topx, topy) = (np.min (x), np.min (y)) (bottomx, bottomy) = (np.max (x), np.max (y)) Recortada = gris
La imagen resultante se muestra a continuación. Normalmente añadido para recortar la imagen, también podemos gris y bordearla si es necesario. Esto se hace para mejorar el reconocimiento de caracteres en el siguiente paso. Sin embargo, descubrí que funciona bien incluso con la imagen original.
3. Reconocimiento de caracteres
El paso final en este reconocimiento de matrículas de Raspberry Pi es leer realmente la información de matrículas de la imagen segmentada. Usaremos el paquete pytesseract para leer caracteres de la imagen, como hicimos en el tutorial anterior. El código para el mismo se da a continuación.
# Lee el número de la placa text = pytesseract.image_to_string (Cropped, config = '- psm 11') print ("El número detectado es:", texto)
Ya hemos explicado cómo configurar un motor Tesseract, así que aquí nuevamente si es necesario podemos configurar el Tesseract OCR para obtener mejores resultados si es necesario. El carácter detectado se imprime en la consola. Cuando se compila, el resultado se muestra a continuación
Como puede ver, la imagen original tenía el número “HR 25 BR9044” y nuestro programa ha detectado que imprimió el mismo valor en la pantalla.
Casos fallidos en el reconocimiento de matrículas
El archivo de proyecto completo de este Reconocimiento de matrículas de Raspberry Pi se puede descargar desde aquí, contiene el programa y las imágenes de prueba que usamos para verificar nuestro programa. Sin decirlo, debe recordarse que los resultados de este método no serán precisos . La precisión depende de la claridad de la imagen, orientación, etc exposición a la luz. Para obtener mejores resultados, puede intentar implementar algoritmos de aprendizaje automático junto con esto.
Para tener una idea, veamos otro ejemplo en el que el automóvil no mira directamente a la cámara.
Como puede ver, nuestro programa pudo detectar correctamente la matrícula y recortarla. Pero la biblioteca Tesseract no ha podido reconocer a los personajes correctamente. En lugar del "TS 08 UE 3396" real, el OCR ha reconocido que es "1508 ye 3396". Problemas como este pueden corregirse utilizando mejores imágenes de orientación o configurando el motor Tesseract .
Otro escenario en el peor de los casos es cuando el contorno no detecta correctamente la matrícula. La imagen de abajo tiene demasiada información de fondo y mala iluminación, por lo que el programa ni siquiera ha podido identificar la matrícula a partir del número. En este caso, tenemos que volver a confiar en el aprendizaje automático o mejorar la calidad de la imagen.
Otros ejemplos exitosos
La mayoría de las veces la calidad y la orientación de la imagen es correcta, el programa pudo identificar la matrícula y leer el número de ella. Las siguientes instantáneas muestran algunos de los resultados exitosos obtenidos. Una vez más, todas las imágenes de prueba y el código utilizado aquí estarán disponibles en el archivo ZIP proporcionado aquí.
Espero que haya entendido el reconocimiento automático de matrículas con Raspberry Pi y haya disfrutado construyendo algo interesante por su cuenta. ¿Qué más crees que se puede hacer con OpenCV y Tesseract ?, déjame saber tu opinión en la sección de comentarios. Si tiene alguna pregunta con respecto a este artículo, no dude en dejarla en la sección de comentarios a continuación o utilizar los foros para otras consultas técnicas.