Detecta y reconoce matrículas de automóviles a partir de un video en tiempo real

Reconocer la matrícula de un automóvil es una tarea muy importante para un sistema de seguridad basado en cámaras de vigilancia. Podemos extraer la matrícula de una imagen usando algunas técnicas de visión por computadora y luego podemos usar el Reconocimiento Óptico de Caracteres para reconocer el número de licencia. Aquí te guiaré a través de todo el procedimiento de esta tarea.
Requisitos: 

opencv-python 3.4.2
numpy
1.17.2 skimage
0.16.2 tensorflow 1.15.0
imutils 0.5.3

Ejemplo: 
 

Aporte: 
 

Salida: 
29A33185 
 

Acercarse: 
 

• Encuentra todos los contornos en la imagen.
• Encuentre el rectángulo delimitador de cada contorno.
• Compare y valide la proporción de lados y el área de cada rectángulo delimitador con una matrícula promedio.
• Aplicar segmentación de imagen en la imagen dentro del contorno validado para encontrar caracteres en ella.
• Reconoce caracteres usando un OCR.

Metodología: 
 

1 . Para reducir el ruido, debemos desenfocar la imagen de entrada con Gaussian Blur y luego convertirla a escala de grises. 
 

2 . Encuentra bordes verticales en la imagen. 
 

3. Para revelar la placa tenemos que binarizar la imagen. Para esto, aplique la Umbralización de Otsu en la imagen del borde vertical. En otros métodos de umbralización, tenemos que elegir un valor de umbral para binarizar la imagen, pero la Umbralización de Otsu determina el valor automáticamente. 
 

4 . Aplicar transformación morfológica de cierre en la imagen con umbral. El cierre es útil para rellenar pequeñas regiones negras entre regiones blancas en una imagen con umbral. Revela la caja blanca rectangular de matrículas. 
 

5. Para detectar la placa necesitamos encontrar contornos en la imagen. Es importante binarizar y transformar la imagen antes de encontrar los contornos para que pueda encontrar un número menor y más relevante de contornos en la imagen. Si dibuja todos los contornos extraídos en la imagen original, se vería así: 
 

6. Ahora encuentre el rectángulo de área mínima encerrado por cada uno de los contornos y valide sus proporciones de lado y área. Hemos definido el área mínima y máxima de la placa como 4500 y 30000 respectivamente.

7. Ahora encuentre los contornos en la región validada y valide las proporciones de los lados y el área del rectángulo delimitador del contorno más grande en esa región. Después de validar, obtendrá un contorno perfecto de una placa de matrícula. Ahora extrae ese contorno de la imagen original. Obtendrás la imagen de la placa: 
 

• Código: este paso lo realiza clean_plate y el método ratioCheck de la clase PlateFinder . 
   

def clean_plate(self, plate):
 
    gray = cv2.cvtColor(plate, cv2.COLOR_BGR2GRAY)
    thresh = cv2.adaptiveThreshold(gray, 255,
                                   cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                   cv2.THRESH_BINARY, 11, 2)
     
    _, contours, _ = cv2.findContours(thresh.copy(),
                                      cv2.RETR_EXTERNAL,
                                      cv2.CHAIN_APPROX_NONE)
 
    if contours:
         
        areas = [cv2.contourArea(c) for c in contours]
         
        # index of the largest contour in the
        # areas array
        max_index = np.argmax(areas) 
 
        max_cnt = contours[max_index]
        max_cntArea = areas[max_index]
        x, y, w, h = cv2.boundingRect(max_cnt)
 
        if not self.ratioCheck(max_cntArea,
                               plate.shape[1],
                               plate.shape[0]):
            return plate, False, None
         
        return plate, True, [x, y, w, h]
     
    else:
        return plate, False, None
 
def ratioCheck(self, area, width, height):
     
    min = self.min_area
    max = self.max_area
 
    ratioMin = 3
    ratioMax = 6
 
    ratio = float(width) / float(height)
     
    if ratio < 1:
        ratio = 1 / ratio
 
    if (area < min or area > max) or (ratio < ratioMin or ratio > ratioMax):
        return False
     
    return True

8. Para reconocer con precisión los caracteres de la matrícula, tenemos que aplicar la segmentación de imágenes. Ese primer paso es extraer el canal de valor del formato HSV de la imagen de la placa. parecería.

9. Ahora aplique un umbral adaptativo en la imagen del canal de valor de la placa para binarizarla y revelar los caracteres. La imagen de la placa puede tener diferentes condiciones de iluminación en diferentes áreas, en ese caso, el umbral adaptativo puede ser más adecuado para binarizar porque utiliza diferentes valores de umbral para diferentes regiones en función del brillo de los píxeles en la región que lo rodea.

10. Después de binarizar, aplique la operación no bit a bit en la imagen para encontrar los componentes conectados en la imagen para que podamos extraer los caracteres candidatos.

11. Construya una máscara para mostrar todos los componentes del carácter y luego busque contornos en la máscara. Después de extraer los contornos, tome el más grande, encuentre su rectángulo delimitador y valide las proporciones de los lados.

12. Después de validar las proporciones de los lados, encuentre el casco convexo del anuncio de contorno y dibújelo en la máscara del candidato del personaje. La máscara se vería como-

13. Ahora encuentre todos los contornos en la máscara de candidato de carácter y extraiga esas áreas de contorno de la imagen con umbral de valor de la placa, obtendrá todos los caracteres por separado. 
 

Los pasos 8 a 13 los realiza la función segment_chars que puede encontrar a continuación en el código fuente completo. El código del controlador para las funciones utilizadas en los pasos 6 a 13 está escrito en el método check_plate de la clase PlateFinder . 
 

Ahora use OCR para reconocer el carácter uno por uno.

Código fuente completo con su funcionamiento: primero, cree una clase PlateFinder que encuentre las placas y valide su relación de tamaño y área. 

import cv2
import numpy as np
from skimage.filters import threshold_local
import tensorflow as tf
from skimage import measure
import imutils
 
 
def sort_cont(character_contours):
    """
    To sort contours
    """
    i = 0
    boundingBoxes = [cv2.boundingRect(c) for c in character_contours]
     
    (character_contours, boundingBoxes) = zip(*sorted(zip(character_contours,
                                                          boundingBoxes),
                                                      key = lambda b: b[1][i],
                                                      reverse = False))
     
    return character_contours
 
 
def segment_chars(plate_img, fixed_width):
     
    """
    extract Value channel from the HSV format
    of image and apply adaptive thresholding
    to reveal the characters on the license plate
    """
    V = cv2.split(cv2.cvtColor(plate_img, cv2.COLOR_BGR2HSV))[2]
 
    thresh = cv2.adaptiveThreshold(value, 255,
                                   cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                   cv2.THRESH_BINARY,
                                   11, 2)
 
    thresh = cv2.bitwise_not(thresh)
 
    # resize the license plate region to
    # a canoncial size
    plate_img = imutils.resize(plate_img, width = fixed_width)
    thresh = imutils.resize(thresh, width = fixed_width)
    bgr_thresh = cv2.cvtColor(thresh, cv2.COLOR_GRAY2BGR)
 
    # perform a connected components analysis
    # and initialize the mask to store the locations
    # of the character candidates
    labels = measure.label(thresh, neighbors = 8, background = 0)
 
    charCandidates = np.zeros(thresh.shape, dtype ='uint8')
 
    # loop over the unique components
    characters = []
    for label in np.unique(labels):
         
        # if this is the background label, ignore it
        if label == 0:
            continue
        # otherwise, construct the label mask to display
        # only connected components for the current label,
        # then find contours in the label mask
        labelMask = np.zeros(thresh.shape, dtype ='uint8')
        labelMask[labels == label] = 255
 
        cnts = cv2.findContours(labelMask,
                     cv2.RETR_EXTERNAL,
                     cv2.CHAIN_APPROX_SIMPLE)
 
        cnts = cnts[0] if imutils.is_cv2() else cnts[1]
 
        # ensure at least one contour was found in the mask
        if len(cnts) > 0:
 
            # grab the largest contour which corresponds
            # to the component in the mask, then grab the
            # bounding box for the contour
            c = max(cnts, key = cv2.contourArea)
            (boxX, boxY, boxW, boxH) = cv2.boundingRect(c)
 
            # compute the aspect ratio, solodity, and
            # height ration for the component
            aspectRatio = boxW / float(boxH)
            solidity = cv2.contourArea(c) / float(boxW * boxH)
            heightRatio = boxH / float(plate_img.shape[0])
 
            # determine if the aspect ratio, solidity,
            # and height of the contour pass the rules
            # tests
            keepAspectRatio = aspectRatio < 1.0
            keepSolidity = solidity > 0.15
            keepHeight = heightRatio > 0.5 and heightRatio < 0.95
 
            # check to see if the component passes
            # all the tests
            if keepAspectRatio and keepSolidity and keepHeight and boxW > 14:
                 
                # compute the convex hull of the contour
                # and draw it on the character candidates
                # mask
                hull = cv2.convexHull(c)
 
                cv2.drawContours(charCandidates, [hull], -1, 255, -1)
 
    _, contours, hier = cv2.findContours(charCandidates,
                                         cv2.RETR_EXTERNAL,
                                         cv2.CHAIN_APPROX_SIMPLE)
     
    if contours:
        contours = sort_cont(contours)
         
        # value to be added to each dimension
        # of the character
        addPixel = 4 
        for c in contours:
            (x, y, w, h) = cv2.boundingRect(c)
            if y > addPixel:
                y = y - addPixel
            else:
                y = 0
            if x > addPixel:
                x = x - addPixel
            else:
                x = 0
            temp = bgr_thresh[y:y + h + (addPixel * 2),
                              x:x + w + (addPixel * 2)]
 
            characters.append(temp)
             
        return characters
     
    else:
        return None
 
 
 
class PlateFinder:
    def __init__(self):
         
        # minimum area of the plate
        self.min_area = 4500 
         
        # maximum area of the plate
        self.max_area = 30000 
 
        self.element_structure = cv2.getStructuringElement(
                              shape = cv2.MORPH_RECT, ksize =(22, 3))
 
    def preprocess(self, input_img):
         
        imgBlurred = cv2.GaussianBlur(input_img, (7, 7), 0)
         
        # convert to gray
        gray = cv2.cvtColor(imgBlurred, cv2.COLOR_BGR2GRAY)
         
        # sobelX to get the vertical edges
        sobelx = cv2.Sobel(gray, cv2.CV_8U, 1, 0, ksize = 3) 
         
        # otsu's thresholding
        ret2, threshold_img = cv2.threshold(sobelx, 0, 255,
                         cv2.THRESH_BINARY + cv2.THRESH_OTSU)
 
        element = self.element_structure
        morph_n_thresholded_img = threshold_img.copy()
        cv2.morphologyEx(src = threshold_img,
                         op = cv2.MORPH_CLOSE,
                         kernel = element,
                         dst = morph_n_thresholded_img)
         
        return morph_n_thresholded_img
 
    def extract_contours(self, after_preprocess):
         
        _, contours, _ = cv2.findContours(after_preprocess,
                                          mode = cv2.RETR_EXTERNAL,
                                          method = cv2.CHAIN_APPROX_NONE)
        return contours
 
    def clean_plate(self, plate):
         
        gray = cv2.cvtColor(plate, cv2.COLOR_BGR2GRAY)
        thresh = cv2.adaptiveThreshold(gray,
                                       255,
                                       cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                       cv2.THRESH_BINARY,
                                       11, 2)
         
        _, contours, _ = cv2.findContours(thresh.copy(),
                                          cv2.RETR_EXTERNAL,
                                          cv2.CHAIN_APPROX_NONE)
 
        if contours:
            areas = [cv2.contourArea(c) for c in contours]
             
            # index of the largest contour in the area
            # array
            max_index = np.argmax(areas) 
 
            max_cnt = contours[max_index]
            max_cntArea = areas[max_index]
            x, y, w, h = cv2.boundingRect(max_cnt)
            rect = cv2.minAreaRect(max_cnt)
             
            if not self.ratioCheck(max_cntArea, plate.shape[1],
                                                plate.shape[0]):
                return plate, False, None
             
            return plate, True, [x, y, w, h]
         
        else:
            return plate, False, None
 
 
 
    def check_plate(self, input_img, contour):
         
        min_rect = cv2.minAreaRect(contour)
         
        if self.validateRatio(min_rect):
            x, y, w, h = cv2.boundingRect(contour)
            after_validation_img = input_img[y:y + h, x:x + w]
            after_clean_plate_img, plateFound, coordinates = self.clean_plate(
                                                        after_validation_img)
             
            if plateFound:
                characters_on_plate = self.find_characters_on_plate(
                                              after_clean_plate_img)
                 
                if (characters_on_plate is not None and len(characters_on_plate) == 8):
                    x1, y1, w1, h1 = coordinates
                    coordinates = x1 + x, y1 + y
                    after_check_plate_img = after_clean_plate_img
                     
                    return after_check_plate_img, characters_on_plate, coordinates
         
        return None, None, None
 
 
 
    def find_possible_plates(self, input_img):
         
        """
        Finding all possible contours that can be plates
        """
        plates = []
        self.char_on_plate = []
        self.corresponding_area = []
 
        self.after_preprocess = self.preprocess(input_img)
        possible_plate_contours = self.extract_contours(self.after_preprocess)
 
        for cnts in possible_plate_contours:
            plate, characters_on_plate, coordinates = self.check_plate(input_img, cnts)
             
            if plate is not None:
                plates.append(plate)
                self.char_on_plate.append(characters_on_plate)
                self.corresponding_area.append(coordinates)
 
        if (len(plates) > 0):
            return plates
         
        else:
            return None
 
    def find_characters_on_plate(self, plate):
 
        charactersFound = segment_chars(plate, 400)
        if charactersFound:
            return charactersFound
 
    # PLATE FEATURES
    def ratioCheck(self, area, width, height):
         
        min = self.min_area
        max = self.max_area
 
        ratioMin = 3
        ratioMax = 6
 
        ratio = float(width) / float(height)
         
        if ratio < 1:
            ratio = 1 / ratio
         
        if (area < min or area > max) or (ratio < ratioMin or ratio > ratioMax):
            return False
         
        return True
 
    def preRatioCheck(self, area, width, height):
         
        min = self.min_area
        max = self.max_area
 
        ratioMin = 2.5
        ratioMax = 7
 
        ratio = float(width) / float(height)
         
        if ratio < 1:
            ratio = 1 / ratio
 
        if (area < min or area > max) or (ratio < ratioMin or ratio > ratioMax):
            return False
         
        return True
 
    def validateRatio(self, rect):
        (x, y), (width, height), rect_angle = rect
 
        if (width > height):
            angle = -rect_angle
        else:
            angle = 90 + rect_angle
 
        if angle > 15:
            return False
         
        if (height == 0 or width == 0):
            return False
 
        area = width * height
         
        if not self.preRatioCheck(area, width, height):
            return False
        else:
            return True

Aquí está la explicación de todos y cada uno de los métodos de la clase PlateFinder . 
En el método de preprocesamiento , se ha realizado el siguiente paso: 
 

• Desenfocar la imagen
• Convertir a escala de grises
• Buscar bordes verticales
• Umbral de la imagen de borde vertical.
• Cierre Morph the Threshold image.

El método extract_contours devuelve todos los contornos externos de la imagen preprocesada. 
El método find_possible_plates preprocesa la imagen con el método de preprocesamiento , luego extrae los contornos con el método extract_contours , luego verifica las proporciones laterales y el área de todos los contornos extraídos y limpia la imagen dentro del contorno con los métodos check_plate y clean_plate . Después de limpiar la imagen de contorno con el método clean_plate , encuentra todos los caracteres en la placa con el método find_characters_on_plate . 
El método find_characters_on_plate usa segment_charsfunción para encontrar los caracteres. Encuentra caracteres calculando el casco convexo de los contornos de una imagen de valor umbral y dibujándolo en los caracteres para revelarlos. 
Código: cree otra clase para inicializar la red neuronal para predecir los caracteres en la matrícula extraída.
 

class OCR:
     
    def __init__(self):
         
        self.model_file = "./model / binary_128_0.50_ver3.pb"
        self.label_file = "./model / binary_128_0.50_labels_ver2.txt"
        self.label = self.load_label(self.label_file)
        self.graph = self.load_graph(self.model_file)
        self.sess = tf.Session(graph = self.graph)
 
    def load_graph(self, modelFile):
         
        graph = tf.Graph()
        graph_def = tf.GraphDef()
         
        with open(modelFile, "rb") as f:
            graph_def.ParseFromString(f.read())
         
        with graph.as_default():
            tf.import_graph_def(graph_def)
         
        return graph
 
    def load_label(self, labelFile):
        label = []
        proto_as_ascii_lines = tf.gfile.GFile(labelFile).readlines()
         
        for l in proto_as_ascii_lines:
            label.append(l.rstrip())
         
        return label
 
    def convert_tensor(self, image, imageSizeOuput):
        """
        takes an image and transform it in tensor
        """
        image = cv2.resize(image,
                           dsize =(imageSizeOuput,
                                  imageSizeOuput),
                           interpolation = cv2.INTER_CUBIC)
         
        np_image_data = np.asarray(image)
        np_image_data = cv2.normalize(np_image_data.astype('float'),
                                      None, -0.5, .5,
                                      cv2.NORM_MINMAX)
         
        np_final = np.expand_dims(np_image_data, axis = 0)
         
        return np_final
 
    def label_image(self, tensor):
 
        input_name = "import / input"
        output_name = "import / final_result"
 
        input_operation = self.graph.get_operation_by_name(input_name)
        output_operation = self.graph.get_operation_by_name(output_name)
 
        results = self.sess.run(output_operation.outputs[0],
                                {input_operation.outputs[0]: tensor})
        results = np.squeeze(results)
        labels = self.label
        top = results.argsort()[-1:][::-1]
         
        return labels[top[0]]
 
    def label_image_list(self, listImages, imageSizeOuput):
        plate = ""
         
        for img in listImages:
             
            if cv2.waitKey(25) & 0xFF == ord('q'):
                break
            plate = plate + self.label_image(self.convert_tensor(img, imageSizeOuput))
         
        return plate, len(plate)

Carga el modelo OCR preentrenado y su archivo de etiquetas en las funciones load_graph y load_label . El método label_image_list transforma la imagen en tensor con el método convert_tensor y luego predice la etiqueta del tensor con la función label_image_list y devuelve el número de licencia. 
Código: cree una función principal para realizar toda la tarea en una secuencia. 
 

if __name__ == "__main__":
     
    findPlate = PlateFinder()
    model = OCR()
 
    cap = cv2.VideoCapture('test_videos / video.MOV')
     
    while (cap.isOpened()):
        ret, img = cap.read()
         
        if ret == True:
            cv2.imshow('original video', img)
             
            if cv2.waitKey(25) & 0xFF == ord('q'):
                break
             
            possible_plates = findPlate.find_possible_plates(img)
             
            if possible_plates is not None:
                 
                for i, p in enumerate(possible_plates):
                    chars_on_plate = findPlate.char_on_plate[i]
                    recognized_plate, _ = model.label_image_list(
                               chars_on_plate, imageSizeOuput = 128)
 
                    print(recognized_plate)
                    cv2.imshow('plate', p)
                     
                    if cv2.waitKey(25) & 0xFF == ord('q'):
                        break
        else:
            break
             
    cap.release()
    cv2.destroyAllWindows()

Puede descargar el código fuente con el modelo OCR y el video de prueba desde mi GitHub . 
¿Cómo mejorar el modelo? 
 

• Puede establecer una región pequeña en particular en el marco para encontrar las placas dentro de ella (asegúrese de que todos los vehículos deben pasar por esa región).
• Puede entrenar su propio modelo de aprendizaje automático para reconocer caracteres porque el modelo dado no reconoce todos los alfabetos.

Referencias: 
Sistema de reconocimiento automático de matrículas (ANPR): una encuesta de Chirag Indravadanbhai Patel.
Técnicas de preprocesamiento de imágenes en la documentación de OpenCV .