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

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/Picamera2e 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
systemde 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:
| Item | Requisito mínimo | Observação |
|---|---|---|
| Placa | Raspberry Pi 3B+ / 4 / 5 | Pi 4 com 4 GB é a opção de melhor custo-benefício |
| Memória RAM | 2 GB | 4 GB recomendado para processar 1280×720 |
| Cartão microSD | 16 GB, classe A1/A2 | 32 GB dá folga para as capturas de debug |
| Fonte de alimentação | 5 V / 3 A | Subtensão derruba a câmera durante a captura |
| Sistema operacional | Raspberry Pi OS Bookworm (64 bits) | A pilha libcamera já vem integrada |
| Câmera | Raspberry Pi Camera V1.3 + cabo FFC 15 vias | Em Pi Zero e Pi 5, usar cabo adaptador 15→22 vias |
1.1 Gravar o cartão e habilitar o acesso remoto
- Baixe o Raspberry Pi Imager em raspberrypi.com/software e selecione o sistema Raspberry Pi OS (64-bit);
- 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; - Na aba Services, marque Enable SSH — isso permite trabalhar pelo terminal de outro computador;
- 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
- Desligue a placa e desconecte a fonte, aguardando alguns segundos;
- Levante a trava plástica do conector
CAMERAda Raspberry Pi; - 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;
- No módulo da câmera, os contatos metálicos ficam voltados para a face da PCB;
- 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.

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:
| Pino | Sinal | Direção | Função |
|---|---|---|---|
| 1 | GND | Referência | Terra comum do cabo |
| 2 | CAM_D0_N | Câmera → Host | Dados MIPI CSI-2, via 0 negativa |
| 3 | CAM_D0_P | Câmera → Host | Dados MIPI CSI-2, via 0 positiva |
| 4 | GND | Referência | Isolamento entre os pares de dados |
| 5 | CAM_D1_N | Câmera → Host | Dados MIPI CSI-2, via 1 negativa |
| 6 | CAM_D1_P | Câmera → Host | Dados MIPI CSI-2, via 1 positiva |
| 7 | GND | Referência | Isolamento entre dados e clock |
| 8 | CAM_CLK_N | Câmera → Host | Clock diferencial MIPI, negativo |
| 9 | CAM_CLK_P | Câmera → Host | Clock diferencial MIPI, positivo |
| 10 | GND | Referência | Isolamento entre MIPI e lógica CMOS |
| 11 | CAM_GPIO0 | Host → Câmera | Habilita regulador/oscilador e sai do power-down |
| 12 | CAM_GPIO1 | Host → Câmera | LED frontal da placa Rev 1.3 |
| 13 | CAM_SCL | Host → Câmera | Clock do barramento I2C/SCCB (0x36) |
| 14 | CAM_SDA | Bidirecional | Dados do barramento I2C/SCCB (0x36) |
| 15 | +3V3 | Alimentação | Entrada 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:
| Pacote | Função no projeto |
|---|---|
python3-picamera2 | Captura de quadros pela pilha oficial libcamera |
python3-opencv | Processamento de imagem e visão computacional |
python3-pytesseract + tesseract-ocr | Motor de OCR e sua interface Python |
python3-pil | Dependê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
picamera2peloapt, não pelopip. A biblioteca é acoplada à versão dalibcamerado sistema, e a instalação viapipcostuma quebrar por incompatibilidade de ABI. Se precisar de um ambiente virtual, crie-o compython3 -m venv --system-site-packages venv, para que opicamera2continue 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.
- Aquisição — a câmera entrega quadros RGB888 em 1280×720;
- Pré-processamento — conversão para tons de cinza e filtro bilateral (reduz ruído preservando bordas);
- Segmentação — gradiente horizontal (Scharr), binarização de Otsu e fechamento morfológico para transformar a placa em um bloco sólido;
- Filtragem geométrica — descarte de contornos por área, proporção e preenchimento;
- Retificação — homografia dos quatro cantos para uma imagem normalizada de 400×130 px;
- Binarização do recorte — limiar adaptativo (com Otsu como reserva) e remoção da moldura;
- OCR e validação — Tesseract com
--psm 7e 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 e o recorte de 1920 pixels de largura, o campo horizontal fica em . A distância focal equivalente em pixels é:
A largura aparente da placa, em pixels, depende da distância e da largura física (400 mm no padrão Mercosul):
A tabela abaixo aplica a relação para uma placa de 400 mm e caracteres de aproximadamente 60 mm de altura:
| Distância | Largura da placa | Altura do caractere | Leitura esperada |
|---|---|---|---|
| 0,5 m | 1355 px | 203 px | Imediata |
| 1,0 m | 678 px | 102 px | Imediata |
| 1,5 m | 452 px | 68 px | Confiável |
| 2,0 m | 339 px | 51 px | Confiável |
| 3,0 m | 226 px | 34 px | Exige foco e luz uniforme |
| 4,0 m | 169 px | 25 px | No limite do OCR |
| 6,0 m | 113 px | 17 px | Falha 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:
O script aceita , 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:
A matriz é 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âmetro | Valor inicial | Efeito quando aumenta |
|---|---|---|
| Kernel do fechamento | (17, 5) | Une bordas distantes; demais, funde a placa ao fundo |
| Área mínima | 4000 px² | Descarta candidatos pequenos; demais, perde placas distantes |
| Faixa de proporção | 2,0 a 5,5 | Estreitar reduz falsos positivos, mas rejeita placas muito inclinadas |
| Ampliação para OCR | 2,0× | Melhora caracteres pequenos ao custo de tempo de processamento |
| Bloco do limiar adaptativo | 31 | Acompanha 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
0quando 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.
| Fator | Configuração recomendada | Motivo técnico |
|---|---|---|
| Iluminação | LED branco difuso, 45° em relação à placa | Evita sombra dos caracteres e reflexo especular |
| Distância | 1,0 m a 2,0 m | Mantém o caractere acima de 50 px de altura |
| Inclinação horizontal | Até ±25° | Acima disso a projeção encolhe a largura e a proporção sai da faixa |
| Inclinação vertical | Até ±15° | Evita o efeito de escada nas bordas dos caracteres |
| Fundo | Superfície escura e sem textura | Aumenta o contraste usado pela segmentação |
| Foco | Fixo, de 1 m ao infinito | A lente não tem ajuste; a distância mínima é 50 cm |
| Placa de teste | Papel fosco, 400×130 mm | Papel 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/:
| Arquivo | O que mostra | O que verificar |
|---|---|---|
*-quadro.jpg | Quadro original com os contornos | A placa está dentro do enquadramento? |
*-mascara.png | Máscara após Otsu e morfologia | A placa virou um bloco sólido e isolado? |
*-placa.png | Recorte retificado de 400×130 | Os 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áscara | Causa provável | Ajuste |
|---|---|---|
| Bloco da placa fragmentado | Contraste baixo entre placa e fundo | Melhorar iluminação; aumentar o kernel para (21, 5) |
| Placa unida ao fundo | Fundo com muitas bordas verticais | Reduzir o kernel para (13, 5) e aumentar AREA_MIN |
| Nenhum contorno | Placa pequena no quadro | Aproximar a câmera ou reduzir AREA_MIN |
| Vários candidatos espalhados | Textura de fundo | Verificar RAZAO_MIN/RAZAO_MAX e o preenchimento mínimo |
| Recorte torto ou cortado | Cantos imprecisos | Conferir 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:
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. ComUser=pi, os arquivos de saída passam a pertencer ao usuáriopi; 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
journalctlmostra a causa em poucos segundos. Os erros mais comuns sãoNo cameras available!(cabo flat ou detecção automática) eUnable 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) | Python | C++ |
|---|---|---|
| Latência por quadro com OCR | 85 a 120 ms | 50 a 70 ms |
| Quadros por segundo no pipeline | 8 a 12 | 15 a 20 |
| Consumo de memória | 180 a 250 MB | 90 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ão | Como implementar | Ganho |
|---|---|---|
| Registro em banco | Trocar o CSV por SQLite (sqlite3 já vem no Raspberry Pi OS) | Consultas por período e por placa |
| Detecção por rede neural | Substituir a segmentação geométrica por YOLO (TensorFlow Lite) | Funciona com ângulo e distância maiores |
| Integração com automação | Publicar 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
| Sintoma | O que verificar | Solução |
|---|---|---|
No cameras available! | Cabo flat, orientação, trava e módulo SUNNY | Remontar o cabo com a placa desligada; conferir camera_auto_detect=1; pressionar o módulo óptico SUNNY contra a PCB |
rpicam-hello não existe | Pacote ausente | sudo apt install -y rpicam-apps |
| Imagem esverdeada ou roxa | Balanço de branco | Manter AwbEnable; se persistir, fixar AwbMode |
| Câmera cai durante a captura | Alimentação insuficiente | Fonte de 5 V / 3 A e cabo curto |
ModuleNotFoundError: picamera2 | Instalação via pip | Reinstalar com apt; em venv, usar --system-site-packages |
ImportError: libcamera | Versão desencontrada | sudo apt full-upgrade e reiniciar |
| Nenhum candidato encontrado | Placa pequena ou sem contraste | Aproximar a câmera; reduzir AREA_MIN |
| Muitos falsos positivos | Fundo com bordas verticais | Estreitar RAZAO_MIN/RAZAO_MAX; melhorar o fundo |
| Recorte com moldura na imagem | Margem insuficiente | Aumentar a margem vertical em preparar_para_ocr |
| OCR lê 6 ou 8 caracteres | Caractere colado na borda | Reduzir a margem horizontal; conferir a retificação |
| Letras confundidas com números | Ambiguidade visual | Aplicar corrigir_por_posicao (Passo 8.1) |
| Leitura oscila entre dois valores | Quadro ruim entrando na votação | Aumentar minimo em voto_estavel; limpar o histórico |
Unable to init server no serviço | Modo gráfico sem display | Executar com --sem-janela (Passo 9) |
| C++ não abre a câmera | Backend de captura | Instalar gstreamer1.0-libcamera; o código tenta o fallback |
| OCR lento na Pi 3 | Carga de processamento | Reduzir 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/libcameraverificada; - Passo 2 — Conectar a Câmera V1.3: cabo FFC de 15 vias montado com a placa desligada, pinagem conferida e sensor
ov5647reconhecido no barramento CSI; - Passo 3 — Instalar as bibliotecas:
Picamera2, OpenCV,pytesseracte Tesseract instalados viaapt, 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.pycom 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
--debugcom 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
systemdcom--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.