Tag: Deteccao Facial

Reconhecimento facial era coisa de filme de espionagem em 2010. Em 2026, é uma biblioteca Python de 15 linhas rodando num computador de R$ 400 que cabe na palma da mão. O que mudou não foi só o hardware — foi o OpenCV, o projeto de visão computacional open-source mais importante do planeta, que transformou processamento de imagem de especialidade acadêmica em commodity para makers. Hoje vou mostrar como montar uma campainha inteligente que reconhece quem está na porta, notifica seu celular e mantém um registro de visitantes — tudo rodando localmente num Raspberry Pi 5.

OpenCV: 25 Anos de Olhos de Máquina

O OpenCV (Open Source Computer Vision Library) nasceu em 1999 como um projeto interno da Intel Research, liderado por Gary Bradski. A ideia original era acelerar aplicações de visão computacional usando as instruções MMX dos processadores Intel da época. Em 2000, foi liberado como open-source sob licença BSD. Desde então, tornou-se a biblioteca mais usada do mundo para processamento de imagem: mais de 2500 algoritmos otimizados, suporte a GPUs via CUDA e OpenCL, bindings para Python, C++, Java, MATLAB.

Em 2001, Paul Viola e Michael Jones publicaram um paper que mudou a história da detecção facial: um algoritmo capaz de detectar rostos em tempo real usando classificadores em cascata baseados em características Haar-like. Esse algoritmo foi incorporado ao OpenCV e, duas décadas depois, ainda é o ponto de entrada mais comum para quem quer brincar com visão computacional. Ele não é o mais preciso (redes neurais convolucionais são melhores), mas é absurdamente rápido e funciona em hardware modesto.

O Hardware: Por Que Raspberry Pi 5

O Raspberry Pi 5, lançado em outubro de 2023, é um salto geracional significativo. Com o chip BCM2712 quad-core ARM Cortex-A76 a 2.4 GHz, 4 ou 8 GB de RAM e suporte a PCIe 2.0 x1, ele tem potência para rodar detecção facial em tempo real a 15-30 FPS sem GPU externa. A versão de 4 GB custa ~R$ 400-500 no Brasil (via importadores como FilipeFlop ou Mercado Livre). Com uma câmera oficial Raspberry Pi Camera Module 3 (8 MP, autofoco, ~R$ 150), você tem uma plataforma de visão computacional poderosa por menos de R$ 600.

Materiais

• Raspberry Pi 5 (4 GB) com cartão microSD de 32 GB+
• Raspberry Pi Camera Module 3 (ou uma webcam USB compatível com Linux)
• Fonte 5V/3A USB-C
• Um buzzer ativo 5V — para a campainha física
• Um botão táctil — o “botão de campainha”
• Resistor 10kΩ para pull-up do botão

Mão na Massa: O Código

Assumindo Raspberry Pi OS Bookworm instalado e Python 3.11 (vem de fábrica), instale as dependências:

sudo apt update
sudo apt install python3-opencv python3-picamera2
pip install opencv-python face-recognition numpy

O face-recognition é uma biblioteca construída sobre o dlib e o OpenCV por Adam Geitgey. Ela abstrai a complexidade de deep learning com uma API de três linhas — literalmente.

Crie o arquivo campainha.py:

import cv2
import face_recognition
import numpy as np
from picamera2 import Picamera2
from datetime import datetime
import json
import os

# Inicializa a câmera
picam2 = Picamera2()
config = picam2.create_preview_configuration(main={"size": (640, 480)})
picam2.configure(config)
picam2.start()

# Carrega fotos de referência (rostos conhecidos)
known_encodings = []
known_names = []

# Crie uma pasta 'faces' com fotos nomeadas: joao.jpg, maria.jpg
faces_dir = "faces"
if os.path.exists(faces_dir):
    for filename in os.listdir(faces_dir):
        if filename.endswith((".jpg", ".png")):
            img = face_recognition.load_image_file(f"{faces_dir}/{filename}")
            encodings = face_recognition.face_encodings(img)
            if encodings:
                known_encodings.append(encodings[0])
                known_names.append(os.path.splitext(filename)[0])

print(f"Rostos carregados: {known_names}")

# Variáveis de estado
last_detection = {}
cooldown = 30  # segundos entre notificações da mesma pessoa

def log_visit(name):
    """Registra a visita em JSON"""
    entry = {
        "timestamp": datetime.now().isoformat(),
        "person": name
    }
    print(f"VISITA: {name} às {entry['timestamp']}")
    # Salva no arquivo de log
    try:
        with open("visits_log.json", "r") as f:
            log = json.load(f)
    except:
        log = []
    log.append(entry)
    with open("visits_log.json", "w") as f:
        json.dump(log, f, indent=2)

print("Campainha Inteligente Iniciada. Pressione Ctrl+C para sair.")

while True:
    frame = picam2.capture_array()
    
    # OpenCV usa BGR, face_recognition usa RGB
    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    
    # Reduz resolução para acelerar processamento
    small_frame = cv2.resize(rgb_frame, (0, 0), fx=0.25, fy=0.25)
    
    # Detecta localizações dos rostos
    face_locations = face_recognition.face_locations(small_frame)
    face_encodings = face_recognition.face_encodings(small_frame, face_locations)
    
    for (top, right, bottom, left), encoding in zip(face_locations, face_encodings):
        name = "Desconhecido"
        color = (0, 0, 255)  # Vermelho para desconhecidos
        
        # Compara com rostos conhecidos
        if known_encodings:
            matches = face_recognition.compare_faces(known_encodings, encoding, tolerance=0.6)
            if True in matches:
                idx = matches.index(True)
                name = known_names[idx]
                color = (0, 255, 0)  # Verde para conhecidos
        
        # Escala de volta para o tamanho original
        top, right, bottom, left = [x * 4 for x in (top, right, bottom, left)]
        
        # Desenha o retângulo
        cv2.rectangle(frame, (left, top), (right, bottom), color, 2)
        cv2.putText(frame, name, (left, top - 10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
        
        # Log com cooldown
        now = datetime.now().timestamp()
        if name not in last_detection or (now - last_detection[name]) > cooldown:
            log_visit(name)
            last_detection[name] = now
    
    # Mostra o frame
    cv2.imshow("Campainha Inteligente", frame)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cv2.destroyAllWindows()
picam2.stop()

Esse código faz cinco coisas: captura frames da câmera a 640×480, reduz para 160×120 para processar mais rápido, detecta rostos (Haar cascade acelerado por CNN via face_recognition), compara com uma base de rostos conhecidos e registra as visitas num arquivo JSON. Tudo local. Nada vai pra nuvem.

Indo Além: Notificação no Celular

O próximo passo é fazer a campainha notificar o celular quando alguém chega. Use o Pushover (app pago, US$ 5 vitalício) ou Telegram Bot API (grátis). Inclua isso no laço principal:

import requests

def notify(name):
    # Usando Telegram Bot API
    bot_token = "SEU_TOKEN"
    chat_id = "SEU_CHAT_ID"
    msg = f"Alguém na porta: {name}"
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    requests.post(url, json={"chat_id": chat_id, "text": msg})

Agora você recebe uma notificação no celular com o nome de quem está na porta. Se for desconhecido, você decide se atende ou não — direto da notificação.

Onde Isso Vai Parar

A campainha que reconhece rostos é o portal de entrada para visão computacional maker. A partir daqui, você pode: detectar placas de carro no portão (EasyOCR + OpenCV), contar pessoas numa loja, identificar objetos numa esteira de produção, fazer leitura de medidores analógicos (gás, água, luz), classificar frutas numa máquina agrícola. O OpenCV é a biblioteca, o Raspberry Pi 5 é o cérebro — o limite é o problema que você quer resolver.

E a pergunta filosófica que fica: se sua campainha sabe quem é você, quem mais precisa saber?

Fontes e Referências

• OpenCV — Site oficial
• face_recognition — Biblioteca Python por Adam Geitgey
• Raspberry Pi 5 — Site oficial
• Raspberry Pi Camera Module 3 — Especificações
• OpenCV — Tutorial de detecção facial
• Telegram Bot API — Documentação
• Raspberry Pi 5 na FilipeFlop
• sentdex — Canal com tutoriais Python e visão computacional