Visão Geral do Sistema

Os óculos inteligentes para navegação representam uma solução inovadora para auxiliar pedestres na travessia segura. Este sistema combina visão computacional e síntese de voz para fornecer informações críticas em tempo real.

Identificação de Passagens de Pedestres

O reconhecimento de faixas de pedestres enfrenta diversos desafios práticos:

• Variações de iluminação ao longo do dia
• Oclusão por veículos, árvores ou outros pedestres
• Diferentes ângulos de observação
• Degradação da pintura das faixas

A abordagem implementada utiliza uma combinação de modelos YOLO e processamento clássico de imagens:

import cv2
import numpy as np

class DetectorFaixaPedestre:
    def __init__(self, caminho_modelo='modelo/faixa.pt'):
        self.modelo = self.carregar_modelo_yolo(caminho_modelo)
        
    def identificar_faixa(self, quadro):
        resultados = self.modelo(quadro)
        caixas_faixa = []
        
        for resultado in resultados:
            if resultado['classe'] == 'faixa_pedestre':
                caixas_faixa.append(resultado['bbox'])
        
        if caixas_faixa:
            cinza = cv2.cvtColor(quadro, cv2.COLOR_BGR2GRAY)
            binario = cv2.adaptiveThreshold(
                cinza, 255, 
                cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                cv2.THRESH_BINARY, 11, 2
            )
            
            linhas = cv2.HoughLinesP(
                binario, 1, np.pi/180, 
                threshold=50, 
                minLineLength=30, 
                maxLineGap=10
            )
            
            linhas_validas = self.filtrar_linhas_faixa(linhas)
            return caixas_faixa, linhas_validas
        
        return [], []
    
    def filtrar_linhas_faixa(self, linhas):
        linhas_selecionadas = []
        if linhas is not None:
            for linha in linhas:
                x1, y1, x2, y2 = linha[0]
                angulo = np.abs(np.arctan2(y2-y1, x2-x1) * 180 / np.pi)
                
                if 0 < angulo < 15 or 165 < angulo < 180:
                    comprimento = np.sqrt((x2-x1)**2 + (y2-y1)**2)
                    if comprimento > 50:
                        linhas_selecionadas.append(linha)
        
        return linhas_selecionadas

Reconhecimento de Semáforos e Contagem Regressiva

O sistema de detecção de semáforos opera em múltiplas etapas:

class DetectorSemaforo:
    def __init__(self, caminho_modelo='modelo/semaforo.pt'):
        self.modelo = self.carregar_modelo(caminho_modelo)
        
    def detectar_semaforos(self, quadro):
        posicoes = self.encontrar_posicoes(quadro)
        resultados = []
        
        for caixa in posicoes:
            x1, y1, x2, y2 = caixa
            regiao = quadro[y1:y2, x1:x2]
            estado = self.reconhecer_estado(regiao)
            contagem = self.ler_contagem_regressiva(regiao)
            
            resultados.append({
                'bbox': caixa,
                'estado': estado,
                'contagem': contagem
            })
        
        return resultados
    
    def reconhecer_estado(self, regiao_semaforo):
        hsv = cv2.cvtColor(regiao_semaforo, cv2.COLOR_BGR2HSV)
        
        # Definição de intervalos de cor
        vermelho_baixo1 = np.array([0, 120, 70])
        vermelho_alto1 = np.array([10, 255, 255])
        vermelho_baixo2 = np.array([170, 120, 70])
        vermelho_alto2 = np.array([180, 255, 255])
        verde_baixo = np.array([40, 40, 40])
        verde_alto = np.array([90, 255, 255])
        amarelo_baixo = np.array([20, 100, 100])
        amarelo_alto = np.array([30, 255, 255])
        
        mascara_vermelha1 = cv2.inRange(hsv, vermelho_baixo1, vermelho_alto1)
        mascara_vermelha2 = cv2.inRange(hsv, vermelho_baixo2, vermelho_alto2)
        mascara_vermelha = cv2.bitwise_or(mascara_vermelha1, mascara_vermelha2)
        mascara_verde = cv2.inRange(hsv, verde_baixo, verde_alto)
        mascara_amarela = cv2.inRange(hsv, amarelo_baixo, amarelo_alto)
        
        pixels_vermelhos = cv2.countNonZero(mascara_vermelha)
        pixels_verdes = cv2.countNonZero(mascara_verde)
        pixels_amarelos = cv2.countNonZero(mascara_amarela)
        
        max_pixels = max(pixels_vermelhos, pixels_verdes, pixels_amarelos)
        
        if max_pixels < 50:
            return 'desconhecido'
        
        if max_pixels == pixels_vermelhos:
            return 'vermelho'
        elif max_pixels == pixels_verdes:
            return 'verde'
        else:
            return 'amarelo'

Sistema de Anúncio por Voz

O componente de áudio utiliza estratégias híbridas para garantir qualidade e baixa latência:

class SistemaVoz:
    def __init__(self):
        self.audios_pregravados = {
            'vermelho': 'audio/vermelho.wav',
            'verde': 'audio/verde.wav',
            'amarelo': 'audio/amarelo.wav',
            'faixa_encontrada': 'audio/faixa.wav'
        }
        self.motor_tts = self.iniciar_motor_tts()
    
    def anunciar(self, tipo_mensagem, **parametros):
        if tipo_mensagem in self.audios_pregravados:
            arquivo_audio = self.audios_pregravados[tipo_mensagem]
            self.reproduzir_audio(arquivo_audio)
        else:
            texto = self.gerar_texto(tipo_mensagem, **parametros)
            self.sintetizar_voz(texto)
    
    def gerar_texto(self, tipo, **dados):
        if tipo == 'contagem':
            segundos = dados.get('segundos', 0)
            return f"Luz verde por mais {segundos} segundos"
        
        elif tipo == 'orientacao_faixa':
            direcao = dados.get('direcao', 'à frente')
            distancia = dados.get('distancia', 0)
            return f"{direcao} {distancia} metros há uma faixa de pedestre"
        
        elif tipo == 'estado_semaforo':
            estado = dados.get('estado', 'desconhecido')
            mensagens = {
                'vermelho': "Sinal vermelho, aguarde",
                'verde': "Sinal verde, pode atravessar",
                'amarelo': "Atenção ao sinal amarelo"
            }
            return mensagens.get(estado, "Prossiga com cautela")
        
        return "Cuidado ao atravessar"

Arquitetura de Processamento em Tempo Real

O sistema utiliza arquitetura multithread para manter baixa latência:

import threading
import queue
import time

class SistemaNavegacaoTempoReal:
    def __init__(self):
        self.camera = FluxoCamera()
        self.detector_faixa = DetectorFaixaPedestre()
        self.detector_semaforo = DetectorSemaforo()
        self.sistema_voz = SistemaVoz()
        
        self.fila_quadros = queue.Queue(maxsize=10)
        self.fila_deteccoes = queue.Queue(maxsize=10)
        self.fila_anuncios = queue.Queue(maxsize=10)
        
        self.executando = False
        
    def iniciar(self):
        self.executando = True
        
        threads = [
            threading.Thread(target=self.thread_captura),
            threading.Thread(target=self.thread_deteccao),
            threading.Thread(target=self.thread_anuncio)
        ]
        
        for thread in threads:
            thread.daemon = True
            thread.start()
    
    def thread_captura(self):
        while self.executando:
            try:
                quadro = self.camera.obter_quadro()
                if quadro is not None:
                    if self.fila_quadros.qsize() < 8:
                        self.fila_quadros.put(quadro)
                    else:
                        try:
                            self.fila_quadros.get_nowait()
                            self.fila_quadros.put(quadro)
                        except queue.Empty:
                            pass
                time.sleep(0.01)
            except Exception as e:
                print(f"Erro na captura: {e}")

Resultados e Desempenho

O sistema demonstrou eficácia em diferentes condições ambientais:

Considerações Finais

Esta implementação demonstra como tecnologias de visão comptuacional podem ser aplicadas para melhorar a mobilidade urbana. O sistema oferece benefícios significativos para usuários com deficiência visual e pedestres em geral, proporcionando informações cruciais para travessias seguras.