Reconhecimento de Placas Usando OpenCV com a Câmera Raspberry Pi V1.3: Projeto Passo a Passo

Reconhecimento de Placas com OpenCV — manual técnico completo

Introdução

Este tutorial apresenta a construção de um leitor de placas veiculares que roda inteiramente em uma placa Raspberry Pi, usando a Câmera Raspberry Pi V1.3 (sensor OmniVision OV5647, 5 MP, interface MIPI CSI-2 — Camera Serial Interface 2) como elemento de captura. O pipeline usa OpenCV para localizar, recortar e retificar a região da placa e o Tesseract para o OCR (Optical Character Recognition — reconhecimento óptico de caracteres) dos sete caracteres, aceitando tanto o padrão Mercosul (LLLNLNN) quanto o padrão antigo (LLLNNNN). Todo o processamento é local: não há envio de imagens para nuvem, nem dependência de internet durante a operação.

O conteúdo está dividido em duas partes e foi escrito para quem está começando em visão computacional com Raspberry Pi. Na primeira, o objetivo é fazer a leitura funcionar: preparar o sistema operacional, conectar a câmera ao barramento CSI, instalar as bibliotecas, montar a bancada e executar o script que exibe a placa reconhecida na tela. Na segunda, o foco é calibrar e evoluir: interpretar as etapas intermediárias do processamento, reduzir erros de leitura, executar o programa como serviço sem monitor e reescrever o pipeline em C++ para ganhar desempenho. Ao final, você terá um leitor de placas reprodutível em bancada e uma base de código organizada para evoluir.

O que você vai aprender:

  • Preparar o Raspberry Pi OS com a pilha libcamera / Picamera2 e o Tesseract
  • Conectar a Câmera V1.3 ao conector CSI e validar o sensor OV5647 no sistema
  • Entender e implementar o pipeline de segmentação de placas no OpenCV
  • Calcular a distância de trabalho a partir do campo de visão e da resolução
  • Corrigir perspectiva, binarizar e executar OCR com validação de padrão
  • Aumentar a taxa de acerto com votação temporal e filtro de nitidez
  • Executar o leitor como serviço systemd e portar o pipeline para C++

Material utilizado: a câmera deste projeto é a Câmera Raspberry Pi V1.3 (OV5647, 5 MP, cabo flat de 15 vias), disponível na loja RoboBuilders. A placa Raspberry Pi, o cartão microSD, a fonte de 5 V e a iluminação de bancada são itens já disponíveis em laboratório.

Parte 1 — Montar a bancada e fazer a leitura funcionar

Nesta parte o código é escrito e executado do zero, com o hardware na mesa. O roteiro segue a ordem física de montagem: primeiro o sistema operacional, depois o cabo flat, depois as bibliotecas e, por fim, o script de visão computacional.

Passo 1 — Preparar o Raspberry Pi

Qualquer modelo da família funciona, mas o desempenho do OCR depende diretamente da CPU. A tabela abaixo resume a configuração usada como referência:

ItemRequisito mínimoObservação
PlacaRaspberry Pi 3B+ / 4 / 5Pi 4 com 4 GB é a opção de melhor custo-benefício
Memória RAM2 GB4 GB recomendado para processar 1280×720
Cartão microSD16 GB, classe A1/A232 GB dá folga para as capturas de debug
Fonte de alimentação5 V / 3 ASubtensão derruba a câmera durante a captura
Sistema operacionalRaspberry Pi OS Bookworm (64 bits)A pilha libcamera já vem integrada
CâmeraRaspberry Pi Camera V1.3 + cabo FFC 15 viasEm Pi Zero e Pi 5, usar cabo adaptador 15→22 vias

1.1 Gravar o cartão e habilitar o acesso remoto

  1. Baixe o Raspberry Pi Imager em raspberrypi.com/software e selecione o sistema Raspberry Pi OS (64-bit);
  2. Antes de gravar, abra Edit Settings (ou Ctrl + Shift + X) e configure o nome do host, o usuário, a senha e a rede WiFi;
  3. Na aba Services, marque Enable SSH — isso permite trabalhar pelo terminal de outro computador;
  4. Grave o cartão, insira no Raspberry Pi e ligue a placa.

Se preferir configurar depois, use o raspi-config:

sudo raspi-config

O menu Interface Options → I2C deve ficar habilitado: o sensor OV5647 é configurado por um barramento I2C/SCCB interno (0x36), e o driver depende dele para detectar a câmera.

1.2 Atualizar o sistema

Com o sistema no ar, atualize os pacotes e reinicie. O kernel e o libcamera mudam com frequência, e versões desencontradas são a causa mais comum de câmera não detectada:

sudo apt update
sudo apt full-upgrade -y
sudo reboot

1.3 Conferir a pilha de câmera

Nas versões atuais do Raspberry Pi OS, os comandos legados raspistill e raspivid foram substituídos por rpicam-*. Confirme a versão instalada:

rpicam-hello --version

A resposta deve indicar rpicam-apps e a versão da libcamera. Se o comando não existir, instale o pacote:

sudo apt install -y rpicam-apps

Passo 2 — Conectar a Câmera Raspberry Pi V1.3 ao conector CSI

A Câmera V1.3 usa o conector FFC de 15 vias com passo de 1,0 mm. A ligação é direta ao conector CAMERA da Raspberry Pi, sem solda e sem alimentação externa: o módulo recebe 3,3 V pelo próprio cabo e consome cerca de 250 mA durante a captura em 1080p.

⛔ Perigo: Nunca insira ou remova o cabo flat com a Raspberry Pi energizada (hot-plugging). O pino de alimentação transporta 3,3 V da malha principal da placa; um desalinhamento durante a inserção sob tensão provoca curto-circuito e pode inutilizar o sensor OV5647 e o circuito de alimentação da placa.

⚠️ Atenção: Não confunda o conector CAMERA (CSI) com o conector DISPLAY (DSI). Ambos têm 15 vias e passo de 1,0 mm, mas a pinagem é diferente — a câmera não funciona no conector de display.

2.1 Orientação do cabo e montagem física

  1. Desligue a placa e desconecte a fonte, aguardando alguns segundos;
  2. Levante a trava plástica do conector CAMERA da Raspberry Pi;
  3. Insira o cabo flat com os contatos metálicos voltados para o lado das portas HDMI e a fita azul de reforço voltada para o lado da Ethernet;
  4. No módulo da câmera, os contatos metálicos ficam voltados para a face da PCB;
  5. Feche a trava, confirme que o cabo está reto e ligue a placa.

Em Raspberry Pi Zero / Zero 2 W e Raspberry Pi 5, o conector é de 22 vias com passo de 0,5 mm. Nesses modelos, use o cabo adaptador 15→22 vias — o cabo de 15 vias não encaixa.

Diagrama de ligação

2.2 Pinagem do conector FFC de 15 vias

A tabela abaixo reproduz o mapeamento elétrico do módulo. As vias de alta velocidade são diferenciais e trafegam blindadas entre os pinos de terra:

PinoSinalDireçãoFunção
1GNDReferênciaTerra comum do cabo
2CAM_D0_NCâmera → HostDados MIPI CSI-2, via 0 negativa
3CAM_D0_PCâmera → HostDados MIPI CSI-2, via 0 positiva
4GNDReferênciaIsolamento entre os pares de dados
5CAM_D1_NCâmera → HostDados MIPI CSI-2, via 1 negativa
6CAM_D1_PCâmera → HostDados MIPI CSI-2, via 1 positiva
7GNDReferênciaIsolamento entre dados e clock
8CAM_CLK_NCâmera → HostClock diferencial MIPI, negativo
9CAM_CLK_PCâmera → HostClock diferencial MIPI, positivo
10GNDReferênciaIsolamento entre MIPI e lógica CMOS
11CAM_GPIO0Host → CâmeraHabilita regulador/oscilador e sai do power-down
12CAM_GPIO1Host → CâmeraLED frontal da placa Rev 1.3
13CAM_SCLHost → CâmeraClock do barramento I2C/SCCB (0x36)
14CAM_SDABidirecionalDados do barramento I2C/SCCB (0x36)
15+3V3AlimentaçãoEntrada de 3,3 V para os reguladores internos

A pinagem completa, com níveis elétricos, limites de tensão e o equacionamento do barramento MIPI, está no manual técnico do produto: Câmera Raspberry Pi V1.3: Manual Técnico Completo.

2.3 Verificar se o sensor foi reconhecido

Com o sistema ligado, liste as câmeras detectadas:

rpicam-hello --list-cameras

A saída esperada é:

Available cameras
-----------------
0 : ov5647 [2592x1944 10-bit GBRG] (/base/soc/i2c0mux/i2c@1/ov5647@36)
    Modes: 'SGBRG10_CSI2P' : 640x480 [58.92 fps]
                             1280x960 [43.25 fps]
                             1920x1080 [30.62 fps]
                             2592x1944 [15.63 fps]

Se aparecer No cameras available!, pressione suavemente o módulo óptico central com a inscrição SUNNY contra a PCB (ele pode soltar no transporte) e confira a orientação do cabo. Para tirar uma foto de teste em 1280×720:

rpicam-still -o teste_bancada.jpg --width 1280 --height 720 -t 2000

Passo 3 — Instalar Picamera2, OpenCV e Tesseract

As três bibliotecas têm papéis distintos no pipeline:

PacoteFunção no projeto
python3-picamera2Captura de quadros pela pilha oficial libcamera
python3-opencvProcessamento de imagem e visão computacional
python3-pytesseract + tesseract-ocrMotor de OCR e sua interface Python
python3-pilDependência de imagem do pytesseract

Instale tudo pelo gerenciador de pacotes do sistema:

sudo apt update
sudo apt install -y python3-picamera2 python3-opencv python3-pytesseract \
                    python3-pil tesseract-ocr

Confirme as versões e o idioma do OCR:

python3 -c "import cv2, pytesseract; print('OpenCV', cv2.__version__)"
tesseract --version
tesseract --list-langs

💡 Dica: instale o picamera2 pelo apt, não pelo pip. A biblioteca é acoplada à versão da libcamera do sistema, e a instalação via pip costuma quebrar por incompatibilidade de ABI. Se precisar de um ambiente virtual, crie-o com python3 -m venv --system-site-packages venv, para que o picamera2 continue visível.

O idioma eng do Tesseract é suficiente: como a leitura é restrita a letras maiúsculas e dígitos por uma whitelist, o modelo de idioma não interfere no resultado.

Passo 4 — Entender o pipeline antes de escrever o código

O reconhecimento não é feito em uma única operação: são sete etapas encadeadas. Entender cada uma é o que permite diagnosticar uma leitura errada depois.

  1. Aquisição — a câmera entrega quadros RGB888 em 1280×720;
  2. Pré-processamento — conversão para tons de cinza e filtro bilateral (reduz ruído preservando bordas);
  3. Segmentação — gradiente horizontal (Scharr), binarização de Otsu e fechamento morfológico para transformar a placa em um bloco sólido;
  4. Filtragem geométrica — descarte de contornos por área, proporção e preenchimento;
  5. Retificação — homografia dos quatro cantos para uma imagem normalizada de 400×130 px;
  6. Binarização do recorte — limiar adaptativo (com Otsu como reserva) e remoção da moldura;
  7. OCR e validação — Tesseract com --psm 7 e expressão regular do formato brasileiro.

4.1 Distância de trabalho e resolução

O campo de visão horizontal útil no modo 1280×720 vem do recorte central de 1920×1080 pixels da matriz de 2592×1944. Com a distância focal de f=3,6 mmf = 3{,}6\,\text{mm} e o recorte de 1920 pixels de largura, o campo horizontal fica em 41,4°41{,}4°. A distância focal equivalente em pixels é:

fpx=Wimg2⋅tan⁡(FOVH2)=12802⋅tan⁡(20,7°)≈1694 pxf_{px} = \frac{W_{img}}{2 \cdot \tan\left(\frac{\text{FOV}_H}{2}\right)} = \frac{1280}{2 \cdot \tan(20{,}7°)} \approx 1694\ \text{px}

A largura aparente da placa, em pixels, depende da distância dd e da largura física WplacaW_{placa} (400 mm no padrão Mercosul):

Npx=fpx⋅WplacadN_{px} = f_{px} \cdot \frac{W_{placa}}{d}

A tabela abaixo aplica a relação para uma placa de 400 mm e caracteres de aproximadamente 60 mm de altura:

DistânciaLargura da placaAltura do caractereLeitura esperada
0,5 m1355 px203 pxImediata
1,0 m678 px102 pxImediata
1,5 m452 px68 pxConfiável
2,0 m339 px51 pxConfiável
3,0 m226 px34 pxExige foco e luz uniforme
4,0 m169 px25 pxNo limite do OCR
6,0 m113 px17 pxFalha provável

O Tesseract trabalha bem com altura de caractere acima de 30 px e começa a errar abaixo de 20 px — por isso a faixa prática de bancada é de 1 m a 3 m.

4.2 Proporção e filtragem de candidatos

A placa tem proporção fixa, o que permite descartar a maior parte dos falsos positivos apenas pela geometria:

r=wh=400130≈3,08r = \frac{w}{h} = \frac{400}{130} \approx 3{,}08

O script aceita 2,0≤r≤5,52{,}0 \le r \le 5{,}5, faixa que cobre a placa vista em ângulo (a projeção reduz a largura aparente) sem admitir faixas, janelas ou fachadas. O preenchimento mínimo de 50% da área do retângulo descarta agrupamentos de bordas sem superfície real.

4.3 Retificação por homografia

Os quatro cantos da placa são mapeados para um retângulo de 400×130 px por uma transformação projetiva:

[x′y′1]≅H[xy1]\begin{bmatrix} x' \\ y' \\ 1 \end{bmatrix} \cong \mathbf{H} \begin{bmatrix} x \\ y \\ 1 \end{bmatrix}

A matriz H\mathbf{H} é obtida com cv2.getPerspectiveTransform a partir de quatro pares de pontos. Sem essa etapa, uma placa inclinada chega ao OCR com perspectiva e os caracteres variam de tamanho ao longo da linha — condição em que o Tesseract erra com frequência.

4.4 Parâmetros que realmente importam

ParâmetroValor inicialEfeito quando aumenta
Kernel do fechamento(17, 5)Une bordas distantes; demais, funde a placa ao fundo
Área mínima4000 px²Descarta candidatos pequenos; demais, perde placas distantes
Faixa de proporção2,0 a 5,5Estreitar reduz falsos positivos, mas rejeita placas muito inclinadas
Ampliação para OCR2,0×Melhora caracteres pequenos ao custo de tempo de processamento
Bloco do limiar adaptativo31Acompanha variações de iluminação; demais, gera ruído

Passo 5 — Escrever o script de reconhecimento

5.1 Criar a pasta de trabalho

mkdir -p ~/placas
cd ~/placas
nano reconhece_placa.py

5.2 Código completo

O script abaixo implementa todas as etapas do pipeline, grava leituras em CSV opcionalmente e aceita o modo offline (--imagem) para testar fotos sem a câmera:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
RoboBuilders - Reconhecimento de placas veiculares com a Camera Raspberry Pi V1.3
Sensor: OmniVision OV5647 (5 MP) | Pipeline: Picamera2 -> OpenCV -> Tesseract

Instalacao no Raspberry Pi OS (Bookworm):
  sudo apt update
  sudo apt install -y python3-picamera2 python3-opencv python3-pytesseract \
                      python3-pil tesseract-ocr

Uso:
  python3 reconhece_placa.py                      # janela em tempo real
  python3 reconhece_placa.py --debug              # grava as etapas do pipeline
  python3 reconhece_placa.py --sem-janela --salvar-dir ~/placas
  python3 reconhece_placa.py --imagem teste.jpg   # testa uma foto sem camera
"""

import argparse
import csv
import os
import re
import time
from collections import Counter, deque
from datetime import datetime

import cv2
import numpy as np
import pytesseract

# ------------------------------------------------------------------ parametros
LARGURA_CAPTURA, ALTURA_CAPTURA = 1280, 720
LARGURA_PLACA, ALTURA_PLACA = 400, 130      # recorte normalizado da placa
AREA_MIN, AREA_MAX = 4000, 400000           # filtro de area do candidato (px)
RAZAO_MIN, RAZAO_MAX = 2.0, 5.5             # proporcao largura/altura da placa
FATOR_AMPLIACAO = 2.0                       # ampliacao antes do OCR
WHITELIST = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

PADRAO_MERCOSUL = re.compile(r"^[A-Z]{3}[0-9][A-Z][0-9]{2}$")
PADRAO_ANTIGA = re.compile(r"^[A-Z]{3}[0-9]{4}$")
HISTORICO = deque(maxlen=15)


# -------------------------------------------------------------------- captura
def configurar_camera():
    """Inicializa a Camera V1.3 via Picamera2 em 1280x720 @ 30 fps."""
    from picamera2 import Picamera2  # import tardio: permite testar sem camera

    picam2 = Picamera2()
    config = picam2.create_preview_configuration(
        main={"size": (LARGURA_CAPTURA, ALTURA_CAPTURA), "format": "RGB888"},
        controls={
            "FrameDurationLimits": (33333, 33333),  # trava em 30 FPS
            "AeEnable": True,                       # auto-exposicao
            "AwbEnable": True,                      # balanco de branco automatico
        },
    )
    picam2.configure(config)
    picam2.start()
    time.sleep(1.0)  # estabiliza AGC/AEC antes do primeiro quadro
    return picam2


# --------------------------------------------------------- segmentacao da placa
def segmentar_candidatos(imagem):
    """Localiza regioes retangulares com assinatura geometrica de placa."""
    cinza = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
    # Filtro bilateral: reduz ruido preservando as bordas dos caracteres
    suave = cv2.bilateralFilter(cinza, 11, 17, 17)

    # Gradiente horizontal (Scharr): realca as transicoes verticais da placa
    gradiente = cv2.convertScaleAbs(cv2.Scharr(suave, cv2.CV_16S, 1, 0))

    # Binarizacao de Otsu: separa bordas fortes do fundo sem limiar fixo
    _, binaria = cv2.threshold(gradiente, 0, 255,
                               cv2.THRESH_BINARY | cv2.THRESH_OTSU)

    # Fechamento morfologico: une bordas verticais proximas em blocos solidos
    nucleo = cv2.getStructuringElement(cv2.MORPH_RECT, (17, 5))
    fechado = cv2.morphologyEx(binaria, cv2.MORPH_CLOSE, nucleo)
    fechado = cv2.erode(fechado, None, iterations=1)
    fechado = cv2.dilate(fechado, None, iterations=2)

    contornos, _ = cv2.findContours(fechado, cv2.RETR_EXTERNAL,
                                    cv2.CHAIN_APPROX_SIMPLE)
    candidatos = []
    for contorno in contornos:
        area = cv2.contourArea(contorno)
        if not AREA_MIN <= area <= AREA_MAX:
            continue

        retangulo = cv2.minAreaRect(contorno)  # suporta placa levemente girada
        (_, _), (lado_a, lado_b), _ = retangulo
        largura, altura = max(lado_a, lado_b), min(lado_a, lado_b)
        if altura < 1:
            continue

        razao = largura / altura
        if not RAZAO_MIN <= razao <= RAZAO_MAX:
            continue

        # Retangulo pouco preenchido = agrupamento de bordas sem placa real
        preenchimento = area / (largura * altura)
        if preenchimento < 0.50:
            continue

        # Contorno simplificado: 4 vertices = cantos reais (corrige perspectiva)
        perimetro = cv2.arcLength(contorno, True)
        aproximado = cv2.approxPolyDP(contorno, 0.02 * perimetro, True)
        if len(aproximado) == 4:
            cantos = aproximado.reshape(4, 2)
        else:
            cantos = cv2.boxPoints(retangulo)

        candidatos.append((cantos, retangulo, area * preenchimento))

    candidatos.sort(key=lambda item: item[2], reverse=True)
    return candidatos, fechado


def ordenar_pontos(pontos):
    """Ordena 4 vertices em (sup. esq., sup. dir., inf. dir., inf. esq.)."""
    pontos = np.asarray(pontos, dtype="float32")
    soma = pontos.sum(axis=1)
    diferenca = np.diff(pontos, axis=1).ravel()
    return np.array([
        pontos[np.argmin(soma)],       # superior esquerdo
        pontos[np.argmin(diferenca)],  # superior direito
        pontos[np.argmax(soma)],       # inferior direito
        pontos[np.argmax(diferenca)],  # inferior esquerdo
    ], dtype="float32")


def corrigir_perspectiva(imagem, pontos,
                         largura=LARGURA_PLACA, altura=ALTURA_PLACA):
    """Aplica homografia e devolve a placa retificada em 400x130 px."""
    origem = ordenar_pontos(pontos)
    destino = np.array([[0, 0],
                        [largura - 1, 0],
                        [largura - 1, altura - 1],
                        [0, altura - 1]], dtype="float32")
    matriz = cv2.getPerspectiveTransform(origem, destino)
    return cv2.warpPerspective(imagem, matriz, (largura, altura),
                               flags=cv2.INTER_CUBIC)


# ------------------------------------------------------------------------ OCR
def preparar_para_ocr(recorte):
    """Amplia, suaviza e recorta a moldura externa da placa."""
    cinza = cv2.cvtColor(recorte, cv2.COLOR_BGR2GRAY)
    # Ampliacao: o Tesseract precisa de ~20 px de altura por caractere
    cinza = cv2.resize(cinza, None, fx=FATOR_AMPLIACAO, fy=FATOR_AMPLIACAO,
                       interpolation=cv2.INTER_CUBIC)
    cinza = cv2.GaussianBlur(cinza, (3, 3), 0)

    # Moldura removida de forma assimetrica: a borda superior/inferior e
    # horizontal (maior margem) e a lateral e vertical (margem pequena)
    margem_x = max(2, int(cinza.shape[1] * 0.01))
    margem_y = max(4, int(cinza.shape[0] * 0.07))
    return cinza[margem_y:-margem_y, margem_x:-margem_x]


def binarizar(cinza, metodo="adaptativa"):
    """Segmenta os caracteres e devolve a imagem pronta para o Tesseract."""
    if metodo == "otsu":
        _, binaria = cv2.threshold(cinza, 0, 255,
                                   cv2.THRESH_BINARY | cv2.THRESH_OTSU)
    else:
        binaria = cv2.adaptiveThreshold(cinza, 255,
                                        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                        cv2.THRESH_BINARY, 31, 10)
    # Margem branca: melhora a segmentacao de caracteres nas extremidades
    return cv2.copyMakeBorder(binaria, 14, 14, 14, 14,
                              cv2.BORDER_CONSTANT, value=255)


def executar_ocr(binaria):
    """Executa o Tesseract e devolve (texto_limpo, confianca_media)."""
    # PSM 7 = uma unica linha de texto; whitelist elimina simbolos indesejados
    config = f"--psm 7 -c tessedit_char_whitelist={WHITELIST}"
    dados = pytesseract.image_to_data(binaria, config=config,
                                      output_type=pytesseract.Output.DICT)

    tokens, confiancas = [], []
    for indice, token in enumerate(dados["text"]):
        token = re.sub(r"[^A-Z0-9]", "", token.upper())
        confianca = float(dados["conf"][indice])
        if token and confianca >= 0:
            tokens.append(token)
            confiancas.append(confianca)

    texto = "".join(tokens)
    media = sum(confiancas) / len(confiancas) if confiancas else 0.0
    return texto, media


def ler_placa(recorte):
    """Tenta binarizacao adaptativa e, se nao validar, Otsu.

    Devolve (texto, confianca_informativa, binaria_usada). A aceitacao da
    leitura e feita pelo padrao da placa (classificar_placa), nao pela
    confianca: com whitelist ativa o Tesseract 5 pode reportar 0%.
    """
    cinza = preparar_para_ocr(recorte)
    texto, confianca, binaria = "", 0.0, None

    for metodo in ("adaptativa", "otsu"):
        binaria = binarizar(cinza, metodo)
        texto, confianca = executar_ocr(binaria)
        if classificar_placa(texto):
            break

    return texto, confianca, binaria


def classificar_placa(texto):
    """Valida o formato brasileiro: Mercosul (LLLNLNN) ou antigo (LLLNNNN)."""
    if PADRAO_MERCOSUL.match(texto):
        return "Mercosul"
    if PADRAO_ANTIGA.match(texto):
        return "Antiga"
    return None


def voto_estavel(texto, minimo=3):
    """Confirmacao temporal: exige o mesmo texto em minimo de leituras."""
    HISTORICO.append(texto)
    candidato, votos = Counter(HISTORICO).most_common(1)[0]
    return candidato if votos >= minimo else None


# ------------------------------------------------------------- auxiliares
def desenhar_resultado(imagem, caixa, texto, confianca, tipo):
    """Desenha o retangulo da placa e a legenda sobre o quadro."""
    pontos = np.int32(caixa)
    cv2.drawContours(imagem, [pontos], -1, (0, 255, 0), 2)
    rotulo = f"{texto} [{tipo}]"
    if confianca > 0:
        rotulo += f" {confianca:.0f}%"
    x, y = int(pontos[:, 0].min()), int(pontos[:, 1].min()) - 10
    cv2.putText(imagem, rotulo, (x, max(y, 20)),
                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)


def salvar_debug(quadro, mascara, recorte, pasta="debug"):
    """Grava as etapas do pipeline para inspecao visual fora da bancada."""
    os.makedirs(pasta, exist_ok=True)
    carimbo = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
    cv2.imwrite(os.path.join(pasta, f"{carimbo}-quadro.jpg"), quadro)
    cv2.imwrite(os.path.join(pasta, f"{carimbo}-mascara.png"), mascara)
    if recorte is not None:
        cv2.imwrite(os.path.join(pasta, f"{carimbo}-placa.png"), recorte)


def registrar_csv(caminho, texto, tipo, confianca):
    """Anexa a leitura em CSV para post-processamento (relatorios, banco)."""
    novo = not os.path.exists(caminho)
    with open(caminho, "a", newline="", encoding="utf-8") as arquivo:
        escritor = csv.writer(arquivo)
        if novo:
            escritor.writerow(["data_hora", "placa", "formato", "confianca"])
        escritor.writerow([datetime.now().isoformat(timespec="seconds"),
                           texto, tipo, f"{confianca:.1f}"])


# ------------------------------------------------------------------- processo
def processar_quadro(quadro, salvar_debug_em=None):
    """Executa o pipeline completo em um quadro BGR e devolve o resultado."""
    candidatos, mascara = segmentar_candidatos(quadro)
    melhor, recorte_melhor, depurado = None, None, False

    for cantos, _, _ in candidatos[:3]:           # avalia os 3 maiores
        recorte = corrigir_perspectiva(quadro, cantos)
        texto, confianca, _ = ler_placa(recorte)
        tipo = classificar_placa(texto)

        if salvar_debug_em and not depurado:
            salvar_debug(salvar_debug_em, mascara, recorte)
            depurado = True

        if tipo:
            melhor, recorte_melhor = (cantos, texto, confianca, tipo), recorte
            break

    return melhor, recorte_melhor, candidatos, mascara


def processar_imagem(caminho):
    """Modo offline: roda o pipeline em uma foto e imprime o resultado."""
    quadro = cv2.imread(caminho)
    if quadro is None:
        print(f"[ERRO] Nao foi possivel abrir {caminho}")
        return

    melhor, _, candidatos, _ = processar_quadro(quadro)
    print(f"[INFO] Candidatos encontrados: {len(candidatos)}")
    if melhor:
        caixa, texto, confianca, tipo = melhor
        desenhar_resultado(quadro, caixa, texto, confianca, tipo)
        detalhe = f" | confianca: {confianca:.1f}%" if confianca > 0 else ""
        print(f"[OK] Placa: {texto} | formato: {tipo}{detalhe}")
    else:
        print("[ALERTA] Nenhuma placa valida reconhecida nesta imagem.")

    cv2.imwrite("resultado.jpg", quadro)
    print("[INFO] Imagem anotada salva em resultado.jpg")


def main():
    parser = argparse.ArgumentParser(
        description="Reconhecimento de placas com Camera Raspberry Pi V1.3")
    parser.add_argument("--debug", action="store_true",
                        help="grava quadro, mascara e recorte da placa")
    parser.add_argument("--sem-janela", action="store_true",
                        help="modo headless (servico, SSH ou sem monitor)")
    parser.add_argument("--salvar-dir", default="",
                        help="pasta para gravar leituras confirmadas")
    parser.add_argument("--imagem", default="",
                        help="processa uma foto estatica e encerra")
    args = parser.parse_args()

    if args.imagem:
        processar_imagem(args.imagem)
        return

    picam2 = configurar_camera()
    janela = not args.sem_janela
    if args.salvar_dir:
        os.makedirs(args.salvar_dir, exist_ok=True)
    if args.debug:
        os.makedirs("debug", exist_ok=True)

    print("[INFO] Camera Raspberry Pi V1.3 (OV5647) iniciada.")
    print("[INFO] Teclas: 's' salva foto | 'm' mostra mascara | 'q' encerra.")

    t_anterior, contador, fps = time.time(), 0, 0.0
    ultimo_salvo, ultimo_quadro, placa_confirmada = 0.0, 0.0, ""

    try:
        while True:
            # capture_array devolve RGB888; o OpenCV trabalha em BGR
            quadro = cv2.cvtColor(picam2.capture_array(), cv2.COLOR_RGB2BGR)
            inicio = time.time()

            melhor, _, candidatos, mascara = processar_quadro(
                quadro, "debug" if args.debug else None)

            if melhor:
                caixa, texto, confianca, tipo = melhor
                desenhar_resultado(quadro, caixa, texto, confianca, tipo)
                placa_confirmada = voto_estavel(texto) or placa_confirmada

                # grava cada leitura nova no maximo a cada 2 segundos
                if args.salvar_dir and placa_confirmada == texto and \
                        (time.time() - ultimo_salvo) > 2.0:
                    carimbo = datetime.now().strftime("%Y%m%d-%H%M%S")
                    cv2.imwrite(os.path.join(args.salvar_dir,
                                             f"{carimbo}-{texto}.jpg"), quadro)
                    registrar_csv(os.path.join(args.salvar_dir, "leituras.csv"),
                                  texto, tipo, confianca)
                    ultimo_salvo = time.time()
            else:
                for cantos, _, _ in candidatos[:5]:
                    cv2.drawContours(quadro, [np.int32(cantos)],
                                     -1, (0, 255, 255), 1)

            # telemetria
            contador += 1
            t_atual = time.time()
            if t_atual - t_anterior >= 1.0:
                fps = contador / (t_atual - t_anterior)
                contador, t_anterior = 0, t_atual
            latencia = (time.time() - inicio) * 1000.0
            cv2.putText(quadro,
                        f"OV5647 | {LARGURA_CAPTURA}x{ALTURA_CAPTURA} | "
                        f"FPS: {fps:.1f} | {latencia:.0f} ms",
                        (20, 35), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
                        (0, 255, 0), 2)
            if placa_confirmada:
                cv2.putText(quadro, f"PLACA: {placa_confirmada}", (20, 75),
                            cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 2)

            if janela:
                cv2.imshow("RoboBuilders - Camera V1.3", quadro)
                tecla = cv2.waitKey(1) & 0xFF
                if tecla == ord("q"):
                    break
                if tecla == ord("s"):
                    nome = datetime.now().strftime("captura_%Y%m%d-%H%M%S.jpg")
                    cv2.imwrite(nome, quadro)
                    print(f"[OK] Foto salva: {nome}")
                if tecla == ord("m"):
                    cv2.imshow("Mascara de segmentacao", mascara)
            elif args.salvar_dir and (time.time() - ultimo_quadro) > 5.0:
                # modo headless: atualiza a imagem de supervisao a cada 5 s
                cv2.imwrite(os.path.join(args.salvar_dir, "ultimo_quadro.jpg"),
                            quadro)
                ultimo_quadro = time.time()

    except KeyboardInterrupt:
        print("\n[INFO] Encerrado pelo operador.")
    finally:
        picam2.stop()
        cv2.destroyAllWindows()
        print("[INFO] Camera liberada com seguranca.")


if __name__ == "__main__":
    main()

💡 Dica: em algumas compilações do Tesseract 5, a confiança reportada volta 0 quando a whitelist está ativa. Por isso o script aceita a leitura pelo formato da placa (expressão regular), e não pela confiança: um texto de sete caracteres que obedeça a LLLNLNN ou LLLNNNN é considerado válido. A confiança continua sendo exibida e gravada no CSV como informação de diagnóstico.

5.3 Executar com a câmera

cd ~/placas
python3 reconhece_placa.py

A janela mostra o vídeo em tempo real, um HUD com resolução, FPS e latência por quadro, e o retângulo verde sobre a placa com a leitura. Os candidatos ainda não confirmados aparecem em amarelo. Saída típica no terminal:

[INFO] Camera Raspberry Pi V1.3 (OV5647) iniciada.
[INFO] Teclas: 's' salva foto | 'm' mostra mascara | 'q' encerra.

Ao alinhar a placa no enquadramento, a linha superior da janela passa a exibir PLACA: ABC1D23 após três leituras iguais consecutivas — essa confirmação evita que um quadro ruim seja registrado.

5.4 Testar sem a câmera

O modo offline processa uma foto estática e grava resultado.jpg com o retângulo anotado. Útil para validar o pipeline antes de montar a bancada:

python3 reconhece_placa.py --imagem teste_bancada.jpg
[INFO] Candidatos encontrados: 1
[OK] Placa: ABC1D23 | formato: Mercosul
[INFO] Imagem anotada salva em resultado.jpg

Passo 6 — Montar a iluminação e o enquadramento

A câmera V1.3 tem filtro IR-Cut integrado: ela não enxerga refletores infravermelhos de 850 nm. Isso significa que a iluminação precisa ser visível — luz branca difusa — e que a leitura noturna depende de LED branco, não de IR.

FatorConfiguração recomendadaMotivo técnico
IluminaçãoLED branco difuso, 45° em relação à placaEvita sombra dos caracteres e reflexo especular
Distância1,0 m a 2,0 mMantém o caractere acima de 50 px de altura
Inclinação horizontalAté ±25°Acima disso a projeção encolhe a largura e a proporção sai da faixa
Inclinação verticalAté ±15°Evita o efeito de escada nas bordas dos caracteres
FundoSuperfície escura e sem texturaAumenta o contraste usado pela segmentação
FocoFixo, de 1 m ao infinitoA lente não tem ajuste; a distância mínima é 50 cm
Placa de testePapel fosco, 400×130 mmPapel brilhante gera reflexo e satura o limiar

⚠️ Atenção: movimentação acima de aproximadamente 1 m/s produz borrão de movimento com exposição automática em ambiente interno. Para veículos em movimento, fixe o tempo de exposição (ExposureTime) em torno de 5 ms e aumente o ganho — a imagem fica mais ruidosa, mas a placa permanece legível.

Conclusão prática: com luz difusa, placa plana e distância entre 1 e 2 metros, o pipeline entrega leituras estáveis a cada poucos quadros. A maior parte das falhas em bancada vem de reflexo na superfície da placa, não do algoritmo.

Parte 2 — Calibrar, executar sem monitor e evoluir

Com a leitura funcionando, o trabalho passa a ser de engenharia: entender onde o pipeline erra, adicionar verificações e colocar o programa para rodar sozinho. A última etapa reescreve o núcleo em C++ para reduzir a latência.

Passo 7 — Depurar o pipeline etapa por etapa

O modo --debug grava, para cada quadro processado, três arquivos na pasta debug/:

ArquivoO que mostraO que verificar
*-quadro.jpgQuadro original com os contornosA placa está dentro do enquadramento?
*-mascara.pngMáscara após Otsu e morfologiaA placa virou um bloco sólido e isolado?
*-placa.pngRecorte retificado de 400×130Os sete caracteres estão inteiros e sem moldura?

Execute por alguns segundos e encerre:

python3 reconhece_placa.py --debug

A leitura da máscara é o diagnóstico mais direto:

Sintoma na máscaraCausa provávelAjuste
Bloco da placa fragmentadoContraste baixo entre placa e fundoMelhorar iluminação; aumentar o kernel para (21, 5)
Placa unida ao fundoFundo com muitas bordas verticaisReduzir o kernel para (13, 5) e aumentar AREA_MIN
Nenhum contornoPlaca pequena no quadroAproximar a câmera ou reduzir AREA_MIN
Vários candidatos espalhadosTextura de fundoVerificar RAZAO_MIN/RAZAO_MAX e o preenchimento mínimo
Recorte torto ou cortadoCantos imprecisosConferir a etapa approxPolyDP; usar fundo mais uniforme

Passo 8 — Aumentar a taxa de acerto

8.1 Corrigir caracteres por posição

O OCR confunde pares visualmente parecidos (O/0, I/1, B/8). Como o formato brasileiro define quais posições são letras e quais são dígitos, a correção pode ser determinística. Adicione ao script:

# Mapeamentos de confusao do OCR: valor lido -> valor esperado na posicao
PARA_LETRA = {"0": "O", "1": "I", "2": "Z", "4": "A",
              "5": "S", "6": "G", "7": "T", "8": "B"}
PARA_DIGITO = {"O": "0", "Q": "0", "D": "0", "I": "1", "L": "1",
               "Z": "2", "A": "4", "S": "5", "G": "6", "T": "7",
               "B": "8", "E": "8"}
LETRAS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
DIGITOS = "0123456789"


def corrigir_por_posicao(texto):
    """Ajusta cada caractere conforme a classe esperada pelo padrao Mercosul.

    Mercosul: L L L N L N N  |  Antigo: L L L N N N N
    """
    if len(texto) != 7:
        return texto

    saida = []
    for indice, caractere in enumerate(texto):
        eh_letra = indice in (0, 1, 2, 4)
        if eh_letra:
            if caractere not in LETRAS:
                caractere = PARA_LETRA.get(caractere, caractere)
        else:
            if caractere not in DIGITOS:
                caractere = PARA_DIGITO.get(caractere, caractere)
        saida.append(caractere)
    return "".join(saida)

A chamada entra logo depois da limpeza do texto, dentro de ler_placa:

    texto = corrigir_por_posicao(texto)

⚠️ Atenção: a correção por posição só vale para o padrão Mercosul (posições 0, 1, 2 e 4 são letras). No padrão antigo (LLLNNNN), a posição 4 é dígito — se o seu cenário for só de placas antigas, ajuste o conjunto de índices para (0, 1, 2).

8.2 Descartar recortes sem nitidez

Um recorte borrado produz texto plausível e errado. A variância do Laplaciano mede o conteúdo de alta frequência da imagem:

σLap2=1N∑i=1N(∇2Ii−∇2I‾)2\sigma^2_{\text{Lap}} = \frac{1}{N} \sum_{i=1}^{N} \left( \nabla^2 I_i - \overline{\nabla^2 I} \right)^2

Valores baixos indicam imagem suave (desfocada); valores altos, bordas bem definidas. Adicione a verificação antes do OCR:

NITIDEZ_MINIMA = 120.0  # calibrar com --debug na sua bancada


def nitidez_suficiente(recorte):
    """Rejeita recortes desfocados usando a variancia do Laplaciano."""
    cinza = cv2.cvtColor(recorte, cv2.COLOR_BGR2GRAY)
    return cv2.Laplacian(cinza, cv2.CV_64F).var() >= NITIDEZ_MINIMA

E use no laço de candidatos:

        if not nitidez_suficiente(recorte):
            continue

💡 Dica: não copie o valor 120 de outro projeto. Rode --debug, meça a variância em dez recortes bons e dez ruins e escolha um limiar entre os dois grupos — a nitidez depende da lente, da luz e do tamanho aparente da placa.

8.3 Exigir consenso entre quadros

O script já confirma a leitura com voto_estavel: o mesmo texto precisa aparecer três vezes no histórico de 15 leituras antes de ser exibido como PLACA:. Ajuste a exigência conforme o cenário:

# No laço principal: quantas leituras iguais confirmam a placa
placa_confirmada = voto_estavel(texto, minimo=3) or placa_confirmada

Para veículos em movimento rápido, reduza minimo para 2 e o histórico para 9 posições; para leitura estática de alta confiabilidade, aumente para 5. O histórico deve ser limpo quando o quadro fica sem candidatos por vários segundos — caso contrário, uma placa antiga pode vencer a votação de uma placa nova:

# No ramo em que a placa foi encontrada, registre o instante da leitura válida
if melhor:
    ultima_leitura = time.time()
    # ... desenho do resultado e votação ...

# No ramo sem candidato: zera o histórico após 5 s sem leitura válida
else:
    if time.time() - ultima_leitura > 5.0:
        HISTORICO.clear()

Declare ultima_leitura = 0.0 junto de ultimo_salvo no início do laço principal. Sem esse carimbo, o teste com ultimo_salvo só limparia o histórico depois de uma gravação em disco — e não quando a câmera simplesmente perde a placa de vista.

Passo 9 — Executar sem monitor como serviço

Em campo, o Raspberry Pi roda sem teclado e sem tela. Nesse modo, use --sem-janela para não abrir janelas do OpenCV (que exigem servidor gráfico) e --salvar-dir para registrar as leituras confirmadas com imagem, CSV e um quadro de supervisão.

Teste manualmente antes de criar o serviço:

cd ~/placas
python3 reconhece_placa.py --sem-janela --salvar-dir ~/placas/leituras

Cada leitura confirmada grava um JPG com carimbo de data/hora e uma linha em leituras.csv:

data_hora,placa,formato,confianca
2026-11-17T09:41:22,ABC1D23,Mercosul,0.0

Crie o serviço em /etc/systemd/system/leitor-placas.service:

[Unit]
Description=Leitor de placas - Camera Raspberry Pi V1.3
After=multi-user.target

[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi/placas
ExecStart=/usr/bin/python3 /home/pi/placas/reconhece_placa.py --sem-janela --salvar-dir /home/pi/placas/leituras
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Ative e acompanhe:

sudo systemctl daemon-reload
sudo systemctl enable --now leitor-placas
sudo systemctl status leitor-placas
journalctl -u leitor-placas -f

⚠️ Atenção: ajuste User= e os caminhos absolutos para o seu usuário real. Com User=pi, os arquivos de saída passam a pertencer ao usuário pi; se você trabalha com outro nome, o serviço falha na primeira gravação com erro de permissão.

💡 Dica: se o serviço reiniciar em laço, o journalctl mostra a causa em poucos segundos. Os erros mais comuns são No cameras available! (cabo flat ou detecção automática) e Unable to init server (janela aberta sem servidor gráfico — faltou --sem-janela).

Passo 10 — Versão em C++ para ganhar desempenho

O Python tem o custo do interpretador e das conversões NumPy por quadro. A mesma lógica em C++ elimina essa camada: na Pi 4 com 4 GB, o pipeline completo em 1280×720 sai de cerca de 8 a 12 quadros por segundo em Python para 15 a 20 quadros por segundo em C++, com o OCR respondendo pela maior parte do tempo em ambos os casos.

Instale as bibliotecas de desenvolvimento:

sudo apt install -y build-essential cmake pkg-config libopencv-dev \
                    libtesseract-dev tesseract-ocr

10.1 CMakeLists.txt

cmake_minimum_required(VERSION 3.16)
project(reconhece_placa CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(OpenCV REQUIRED)
find_package(PkgConfig REQUIRED)
pkg_check_modules(TESSERACT REQUIRED tesseract)

add_executable(reconhece_placa main.cpp)
target_include_directories(reconhece_placa PRIVATE ${TESSERACT_INCLUDE_DIRS})
target_compile_options(reconhece_placa PRIVATE -O2 ${TESSERACT_CFLAGS_OTHER})
target_link_libraries(reconhece_placa PRIVATE ${OpenCV_LIBS} ${TESSERACT_LIBRARIES})

10.2 main.cpp

/**
 * ============================================================================
 * RoboBuilders - Reconhecimento de placas com a Camera Raspberry Pi V1.3
 * Versao nativa em C++: OpenCV (captura) + Tesseract OCR
 *
 * Hardware: Camera Raspberry Pi V1.3 (OmniVision OV5647, 5 MP, MIPI CSI-2)
 * Compilacao (Raspberry Pi OS Bookworm):
 *   sudo apt install -y build-essential cmake pkg-config libopencv-dev \
 *                       libtesseract-dev tesseract-ocr
 *   cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build -j4
 *
 * Execucao:
 *   ./build/reconhece_placa          # janela em tempo real
 *   ./build/reconhece_placa --debug  # grava as etapas em disco
 * ============================================================================
 */

#include <opencv2/opencv.hpp>
#include <tesseract/baseapi.h>

#include <algorithm>
#include <chrono>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <regex>
#include <string>
#include <vector>

namespace {

constexpr int kLargura = 1280;
constexpr int kAltura = 720;
constexpr int kLarguraPlaca = 400;
constexpr int kAlturaPlaca = 130;
constexpr double kAreaMin = 4000.0;
constexpr double kAreaMax = 400000.0;
constexpr double kRazaoMin = 2.0;
constexpr double kRazaoMax = 5.5;

const char* kWhitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
const std::regex kMercosul("^[A-Z]{3}[0-9][A-Z][0-9]{2}$");
const std::regex kAntiga("^[A-Z]{3}[0-9]{4}$");

struct Candidato {
  cv::RotatedRect retangulo;
  std::vector<cv::Point2f> cantos;
  double pontuacao = 0.0;
};

// Ordena os 4 vertices: superior esquerdo, superior direito, inferior
// direito e inferior esquerdo (ordem exigida pela homografia).
std::vector<cv::Point2f> ordenarPontos(const std::vector<cv::Point2f>& pontos) {
  std::vector<cv::Point2f> ordenados(4);
  std::vector<float> somas, diferencas;
  for (const auto& p : pontos) {
    somas.push_back(p.x + p.y);
    diferencas.push_back(p.x - p.y);
  }
  ordenados[0] = pontos[std::distance(somas.begin(),
                            std::min_element(somas.begin(), somas.end()))];
  ordenados[2] = pontos[std::distance(somas.begin(),
                            std::max_element(somas.begin(), somas.end()))];
  ordenados[1] = pontos[std::distance(diferencas.begin(),
                            std::max_element(diferencas.begin(), diferencas.end()))];
  ordenados[3] = pontos[std::distance(diferencas.begin(),
                            std::min_element(diferencas.begin(), diferencas.end()))];
  return ordenados;
}

// Aplica a homografia e devolve a placa retificada em 400x130 px.
cv::Mat corrigirPerspectiva(const cv::Mat& imagem,
                            const std::vector<cv::Point2f>& cantos) {
  const std::vector<cv::Point2f> origem = ordenarPontos(cantos);
  const std::vector<cv::Point2f> destino = {
      {0.0f, 0.0f},
      {static_cast<float>(kLarguraPlaca - 1), 0.0f},
      {static_cast<float>(kLarguraPlaca - 1), static_cast<float>(kAlturaPlaca - 1)},
      {0.0f, static_cast<float>(kAlturaPlaca - 1)}};

  const cv::Mat matriz = cv::getPerspectiveTransform(origem, destino);
  cv::Mat recorte;
  cv::warpPerspective(imagem, recorte, matriz,
                      cv::Size(kLarguraPlaca, kAlturaPlaca),
                      cv::INTER_CUBIC);
  return recorte;
}

// Localiza regioes com assinatura geometrica de placa (gradiente + morfologia).
std::vector<Candidato> segmentar(const cv::Mat& imagem, cv::Mat& mascara) {
  cv::Mat cinza, suave, gradiente, binaria, fechado;
  cv::cvtColor(imagem, cinza, cv::COLOR_BGR2GRAY);
  cv::bilateralFilter(cinza, suave, 11, 17, 17);

  // Gradiente horizontal: realca as transicoes verticais da placa
  cv::Mat gradiente16;
  cv::Scharr(suave, gradiente16, CV_16S, 1, 0);
  cv::convertScaleAbs(gradiente16, gradiente);

  cv::threshold(gradiente, binaria, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
  const cv::Mat nucleo = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(17, 5));
  cv::morphologyEx(binaria, fechado, cv::MORPH_CLOSE, nucleo);
  cv::erode(fechado, fechado, cv::Mat(), cv::Point(-1, -1), 1);
  cv::dilate(fechado, fechado, cv::Mat(), cv::Point(-1, -1), 2);
  mascara = fechado;

  std::vector<std::vector<cv::Point>> contornos;
  cv::findContours(fechado, contornos, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

  std::vector<Candidato> candidatos;
  for (const auto& contorno : contornos) {
    const double area = cv::contourArea(contorno);
    if (area < kAreaMin || area > kAreaMax) continue;

    Candidato candidato;
    candidato.retangulo = cv::minAreaRect(contorno);
    const cv::Size2f dimensoes = candidato.retangulo.size;
    const double largura = std::max(dimensoes.width, dimensoes.height);
    const double altura = std::min(dimensoes.width, dimensoes.height);
    if (altura < 1.0) continue;

    const double razao = largura / altura;
    if (razao < kRazaoMin || razao > kRazaoMax) continue;

    const double preenchimento = area / (largura * altura);
    if (preenchimento < 0.50) continue;

    // Contorno simplificado: 4 vertices = cantos reais da placa
    const double perimetro = cv::arcLength(contorno, true);
    std::vector<cv::Point> aproximado;
    cv::approxPolyDP(contorno, aproximado, 0.02 * perimetro, true);

    std::vector<cv::Point2f> cantos;
    if (aproximado.size() == 4) {
      for (const auto& p : aproximado) cantos.emplace_back(p.x, p.y);
    } else {
      cv::Point2f vertices[4];
      candidato.retangulo.points(vertices);
      cantos.assign(vertices, vertices + 4);
    }

    candidato.cantos = cantos;
    candidato.pontuacao = area * preenchimento;
    candidatos.push_back(candidato);
  }

  std::sort(candidatos.begin(), candidatos.end(),
            [](const Candidato& a, const Candidato& b) {
              return a.pontuacao > b.pontuacao;
            });
  return candidatos;
}

// Amplia, recorta a moldura e binariza o recorte da placa.
cv::Mat prepararParaOcr(const cv::Mat& recorte, bool usarOtsu) {
  cv::Mat cinza, ampliado, suave, binaria;
  cv::cvtColor(recorte, cinza, cv::COLOR_BGR2GRAY);
  cv::resize(cinza, ampliado, cv::Size(), 2.0, 2.0, cv::INTER_CUBIC);
  cv::GaussianBlur(ampliado, suave, cv::Size(3, 3), 0);

  if (usarOtsu) {
    cv::threshold(suave, binaria, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
  } else {
    cv::adaptiveThreshold(suave, binaria, 255,
                          cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY,
                          31, 10);
  }

  // Remove a moldura: margem horizontal pequena e vertical maior
  const int margemX = std::max(2, static_cast<int>(binaria.cols * 0.01));
  const int margemY = std::max(4, static_cast<int>(binaria.rows * 0.07));
  cv::Mat interno = binaria(
      cv::Rect(margemX, margemY,
               binaria.cols - 2 * margemX, binaria.rows - 2 * margemY));

  // Margem branca: melhora a segmentacao nas extremidades da placa
  cv::Mat pronto;
  cv::copyMakeBorder(interno, pronto, 14, 14, 14, 14,
                     cv::BORDER_CONSTANT, cv::Scalar(255));
  return pronto;
}

std::string limparTexto(const std::string& bruto) {
  std::string limpo;
  for (char c : bruto) {
    if (c >= 'a' && c <= 'z') c = static_cast<char>(c - 'a' + 'A');
    if ((c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) limpo.push_back(c);
  }
  return limpo;
}

// Executa o OCR e devolve o texto; a confianca volta por referencia.
std::string lerPlaca(const cv::Mat& recorte, tesseract::TessBaseAPI& ocr,
                     int& confianca) {
  std::string texto;
  confianca = 0;

  for (bool usarOtsu : {false, true}) {
    cv::Mat binaria = prepararParaOcr(recorte, usarOtsu);
    ocr.SetImage(binaria.data, binaria.cols, binaria.rows, 1,
                 static_cast<int>(binaria.step));

    char* bruto = ocr.GetUTF8Text();
    texto = bruto ? limparTexto(bruto) : "";
    delete[] bruto;
    confianca = ocr.MeanTextConf();
    ocr.Clear();

    if (std::regex_match(texto, kMercosul) ||
        std::regex_match(texto, kAntiga)) {
      break;
    }
  }
  return texto;
}

// Abre a camera: primeiro V4L2 e, se falhar, pipeline GStreamer/libcamera.
bool abrirCamera(cv::VideoCapture& captura) {
  captura.open(0, cv::CAP_V4L2);
  if (!captura.isOpened()) {
    const std::string pipeline =
        "libcamerasrc ! video/x-raw,width=1280,height=720,framerate=30/1 ! "
        "videoconvert ! video/x-raw,format=BGR ! appsink";
    captura.open(pipeline, cv::CAP_GSTREAMER);
  }
  if (!captura.isOpened()) return false;

  captura.set(cv::CAP_PROP_FRAME_WIDTH, kLargura);
  captura.set(cv::CAP_PROP_FRAME_HEIGHT, kAltura);
  captura.set(cv::CAP_PROP_FPS, 30);
  return true;
}

}  // namespace

int main(int argc, char** argv) {
  const bool depurar = (argc > 1 && std::string(argv[1]) == "--debug");

  tesseract::TessBaseAPI ocr;
  if (ocr.Init(nullptr, "eng") != 0) {
    std::cerr << "[ERRO] Tessdata nao encontrado. Instale o pacote "
                 "tesseract-ocr.\n";
    return 1;
  }
  ocr.SetVariable("tessedit_char_whitelist", kWhitelist);
  ocr.SetPageSegMode(tesseract::PSM_SINGLE_LINE);

  cv::VideoCapture captura;
  if (!abrirCamera(captura)) {
    std::cerr << "[ERRO] Camera V1.3 nao encontrada. Verifique o cabo FFC e "
                 "'rpicam-hello --list-cameras'.\n";
    return 1;
  }

  std::cout << "[INFO] Camera V1.3 (OV5647) iniciada em 1280x720 @ 30 fps.\n"
            << "[INFO] Pressione 'q' na janela para encerrar.\n";

  int quadroAtual = 0;
  int contadorFps = 0;
  double fps = 0.0;
  auto inicioFps = std::chrono::steady_clock::now();

  cv::Mat quadro;
  while (true) {
    captura >> quadro;
    if (quadro.empty()) {
      std::cerr << "[ERRO] Quadro vazio: verifique a camera e o cabo FFC.\n";
      break;
    }

    const auto inicio = std::chrono::steady_clock::now();
    cv::Mat mascara;
    const std::vector<Candidato> candidatos = segmentar(quadro, mascara);

    bool encontrada = false;
    std::string placa, formato;
    int confianca = 0;
    size_t indiceEncontrado = 0;

    const size_t limite = std::min<size_t>(candidatos.size(), 3);
    for (size_t i = 0; i < limite; ++i) {
      const Candidato& candidato = candidatos[i];
      const cv::Mat recorte = corrigirPerspectiva(quadro, candidato.cantos);
      const std::string texto = lerPlaca(recorte, ocr, confianca);

      if (depurar) {
        cv::imwrite("debug/placa-" + std::to_string(quadroAtual) + "-" +
                        std::to_string(i) + ".png", recorte);
      }

      if (std::regex_match(texto, kMercosul)) {
        placa = texto;
        formato = "Mercosul";
        encontrada = true;
        indiceEncontrado = i;
        break;
      }
      if (std::regex_match(texto, kAntiga)) {
        placa = texto;
        formato = "Antiga";
        encontrada = true;
        indiceEncontrado = i;
        break;
      }
    }

    if (encontrada) {
      // Desenha o retangulo do candidato que realmente foi reconhecido
      const Candidato& candidato = candidatos[indiceEncontrado];
      std::vector<std::vector<cv::Point>> poligono = {
          std::vector<cv::Point>(candidato.cantos.begin(),
                                 candidato.cantos.end())};
      cv::polylines(quadro, poligono, true, cv::Scalar(0, 255, 0), 2);
      cv::putText(quadro, placa + " [" + formato + "]",
                  cv::Point(20, 75), cv::FONT_HERSHEY_SIMPLEX, 1.0,
                  cv::Scalar(0, 255, 0), 2);
      std::cout << "[OK] Placa: " << placa << " | formato: " << formato
                << " | confianca: " << confianca << "%\n";
    }

    // Telemetria de desempenho
    ++contadorFps;
    const auto agora = std::chrono::steady_clock::now();
    if (std::chrono::duration<double>(agora - inicioFps).count() >= 1.0) {
      fps = contadorFps / std::chrono::duration<double>(agora - inicioFps).count();
      contadorFps = 0;
      inicioFps = agora;
    }
    const double latencia =
        std::chrono::duration<double, std::milli>(agora - inicio).count();

    char hud[128];
    std::snprintf(hud, sizeof(hud), "OV5647 | %dx%d | FPS: %.1f | %.0f ms",
                  kLargura, kAltura, fps, latencia);
    cv::putText(quadro, hud, cv::Point(20, 35), cv::FONT_HERSHEY_SIMPLEX,
                0.7, cv::Scalar(0, 255, 0), 2);

    if (depurar) {
      cv::imwrite("debug/quadro-" + std::to_string(quadroAtual) + ".jpg", quadro);
      cv::imwrite("debug/mascara-" + std::to_string(quadroAtual) + ".png", mascara);
    }
    ++quadroAtual;

    cv::imshow("RoboBuilders - Camera V1.3 (C++)", quadro);
    if ((cv::waitKey(1) & 0xFF) == 'q') break;
  }

  captura.release();
  cv::destroyAllWindows();
  std::cout << "[INFO] Camera liberada com seguranca.\n";
  return 0;
}

10.3 Compilar e executar

mkdir -p ~/placas/cpp/debug
cd ~/placas/cpp
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j4
./build/reconhece_placa

Se a captura V4L2 não abrir, instale o plugin GStreamer da libcamera — o código já tenta esse caminho automaticamente:

sudo apt install -y gstreamer1.0-libcamera libopencv-dev
Métrica (Pi 4, 4 GB, 1280×720)PythonC++
Latência por quadro com OCR85 a 120 ms50 a 70 ms
Quadros por segundo no pipeline8 a 1215 a 20
Consumo de memória180 a 250 MB90 a 140 MB

💡 Dica: os valores acima são referência de bancada, não garantia. O tempo do OCR depende do número de candidatos avaliados: reduzir o laço de 3 para 1 candidato corta cerca de dois terços do custo quando a placa é o único objeto no quadro.

Passo 11 — Evoluir o projeto

Com o pipeline estável, três extensões são naturais:

ExtensãoComo implementarGanho
Registro em bancoTrocar o CSV por SQLite (sqlite3 já vem no Raspberry Pi OS)Consultas por período e por placa
Detecção por rede neuralSubstituir a segmentação geométrica por YOLO (TensorFlow Lite)Funciona com ângulo e distância maiores
Integração com automaçãoPublicar a leitura em MQTT (Home Assistant, Node-RED)Abertura de cancela e registro remoto

O registro em SQLite substitui registrar_csv mantendo a mesma assinatura:

import sqlite3

BANCO = "placas.db"


def registrar_leitura(texto, tipo, confianca):
    """Grava a leitura em SQLite, criando a tabela no primeiro uso."""
    with sqlite3.connect(BANCO) as conexao:
        conexao.execute("""
            CREATE TABLE IF NOT EXISTS leituras (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                data_hora TEXT NOT NULL,
                placa TEXT NOT NULL,
                formato TEXT,
                confianca REAL
            )
        """)
        conexao.execute(
            "INSERT INTO leituras (data_hora, placa, formato, confianca) "
            "VALUES (?, ?, ?, ?)",
            (datetime.now().isoformat(timespec="seconds"), texto, tipo, confianca),
        )

⚠️ Atenção: o projeto faz reconhecimento óptico de caracteres em imagens de veículos e, portanto, trata dados pessoais. Armazene apenas a placa, o horário e a confiança — não mantenha fotos identificáveis além do necessário — e siga as regras da LGPD (Lei Geral de Proteção de Dados) aplicáveis ao seu uso.

Problemas comuns e soluções

SintomaO que verificarSolução
No cameras available!Cabo flat, orientação, trava e módulo SUNNYRemontar o cabo com a placa desligada; conferir camera_auto_detect=1; pressionar o módulo óptico SUNNY contra a PCB
rpicam-hello não existePacote ausentesudo apt install -y rpicam-apps
Imagem esverdeada ou roxaBalanço de brancoManter AwbEnable; se persistir, fixar AwbMode
Câmera cai durante a capturaAlimentação insuficienteFonte de 5 V / 3 A e cabo curto
ModuleNotFoundError: picamera2Instalação via pipReinstalar com apt; em venv, usar --system-site-packages
ImportError: libcameraVersão desencontradasudo apt full-upgrade e reiniciar
Nenhum candidato encontradoPlaca pequena ou sem contrasteAproximar a câmera; reduzir AREA_MIN
Muitos falsos positivosFundo com bordas verticaisEstreitar RAZAO_MIN/RAZAO_MAX; melhorar o fundo
Recorte com moldura na imagemMargem insuficienteAumentar a margem vertical em preparar_para_ocr
OCR lê 6 ou 8 caracteresCaractere colado na bordaReduzir a margem horizontal; conferir a retificação
Letras confundidas com númerosAmbiguidade visualAplicar corrigir_por_posicao (Passo 8.1)
Leitura oscila entre dois valoresQuadro ruim entrando na votaçãoAumentar minimo em voto_estavel; limpar o histórico
Unable to init server no serviçoModo gráfico sem displayExecutar com --sem-janela (Passo 9)
C++ não abre a câmeraBackend de capturaInstalar gstreamer1.0-libcamera; o código tenta o fallback
OCR lento na Pi 3Carga de processamentoReduzir para 800×600 e avaliar 1 candidato

Conclusão

O projeto entregou um leitor de placas completo, do sistema operacional à captura em C++, com todo o processamento executado localmente na Raspberry Pi. Resumo do que foi feito:

  • Passo 1 — Preparar o Raspberry Pi: Raspberry Pi OS Bookworm atualizado, SSH habilitado e pilha rpicam-apps/libcamera verificada;
  • Passo 2 — Conectar a Câmera V1.3: cabo FFC de 15 vias montado com a placa desligada, pinagem conferida e sensor ov5647 reconhecido no barramento CSI;
  • Passo 3 — Instalar as bibliotecas: Picamera2, OpenCV, pytesseract e Tesseract instalados via apt, com as versões confirmadas;
  • Passo 4 — Entender o pipeline: as sete etapas explicadas, com o cálculo da distância de trabalho, da proporção da placa e da homografia de retificação;
  • Passo 5 — Escrever o script: reconhece_placa.py com captura, segmentação, retificação, OCR, validação por expressão regular, votação temporal e gravação em CSV;
  • Passo 6 — Montar a bancada: iluminação difusa, distância de 1 a 2 m e cuidado com o filtro IR-Cut da câmera;
  • Passo 7 — Depurar o pipeline: modo --debug com quadro, máscara e recorte, e tabela de diagnóstico por sintoma;
  • Passo 8 — Aumentar a taxa de acerto: correção de caracteres por posição, filtro de nitidez por variância do Laplaciano e consenso entre quadros;
  • Passo 9 — Executar sem monitor: serviço systemd com --sem-janela, gravação de imagens e log em CSV;
  • Passo 10 — Versão em C++: pipeline equivalente com OpenCV e a API C++ do Tesseract, compilado por CMake e com fallback de captura V4L2/GStreamer;
  • Passo 11 — Evoluir: registro em SQLite, detecção por rede neural e integração via MQTT.

O caminho de evolução segue uma ordem prática: primeiro estabilizar a captura (luz, distância e foco), depois ajustar a segmentação com as imagens de debug e, só então, trocar o OCR por um modelo mais robusto. Para os detalhes elétricos do módulo — níveis de tensão, barramento MIPI e limites absolutos — consulte o manual técnico da Câmera Raspberry Pi V1.3.

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Reconhecimento de Placas Usando OpenCV com a Câmera Raspberry Pi V1.3: Projeto Passo a Passo e eu ajudarei a encontrar a solução.

O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.