Tecnologia por Trás dos Semáforos Inteligentes de SP

1 INTRODUÇÃO

Se você é de São Paulo e assistiu à reportagem do Bom Dia São Paulo desta manhã (21/08), você deve ter se deparado com a matéria sobre os semáforos inteligentes que estão sendo implementados na capital. E se você é uma pessoa curiosa, deve ter se questionado sobre as tecnologias por trás dessa solução.

Os semáforos inteligentes, como são conhecidos, têm essa denominação pois são capazes de ajustar de forma dinâmica os tempos de sinal verde e vermelho. Esse ajuste é feito com base no número de veículos nas vias. Esta abordagem visa otimizar o fluxo do tráfego, proporcionando uma experiência mais eficiente para todos.

Neste artigo, exploraremos uma das possíveis tecnologias que sustentam esses semáforos inteligentes.

2 DETECÇÃO DE CARROS

A BASE DA INTELIGÊNCIA SEMAFÓRICA

O que torna os semáforos inteligentes é a capacidade de detectar a presença de veículos nas vias, resultando numa resposta em tempo real às condições de tráfego. A detecção é realizada através de câmeras de monitoramento posicionadas estrategicamente nas vias. As imagens são processadas por algoritmos de visão computacional que identificam e rastreiam os veículos na imagem. É então que, baseado na quantidade de carros em cada via, o algoritmo passa a instrução ao semáforo por quanto tempo ele deve permanecer em cada sinal.

Figura 1: Carros Detectados na Imagem da Câmera de Monitoramento

3 INTELIGÊNCIA EM AÇÃO: DINAMISMO

O que torna o semáforo inteligente é o dinamismo. Enquanto os semáforos tradicionais não possuem flexibilidade de tempo, os semáforos inteligentes estão sempre avaliando a situação do tráfego. Com base nos dados coletados pelas câmeras de monitoramento, esses sistemas podem identificar padrões de tráfego, prever picos de movimento e até mesmo responder a situações de tráfego inesperadas, como acidentes ou eventos especiais.

Tudo isso é possível graças à combinação de tecnologias como processamento de imagem avançado, algoritmos de aprendizado de máquina e conectividade de rede. Esses componentes trabalham em conjunto para garantir que o fluxo do tráfego seja regulado de maneira eficiente e suave, minimizando congestionamentos e melhorando a experiência de dirigir nas cidades.

4 EXEMPLO DE ALGORITMO ADAPTATIVO PARA SEMÁFORO INTELIGENTE

Vamos adentrar nesse tópico e explorar um exemplo de algoritmo que ilustra o funcionamento desse conceito.

import time

class Camera:
  def __init__(self, posicao):
      self.posicao = posicao
  
  def verifica_trafego(self):
      # Simulando a captura de dados da câmera
      # Retorna informações sobre veículos, pedestres, etc.
      return {"veiculos": 5, "pedestres": 2}

class SemaforoInteligente:
  def __init__(self, cameras):
      self.cameras = cameras
      self.duracao_sinal_verde = 30
  
  def ajustar_sinal(self):
      total_veiculos = 0
      total_pedestres = 0
      
      # Captura dados de todas as câmeras
      for camera in self.cameras:
          dados = camera.verifica_trafego()
          total_veiculos += dados["veiculos"]
          total_pedestres += dados["pedestres"]
      
      # Lógica para ajustar a duração do sinal verde com base nos dados
      if total_veiculos > 10:
          self.duracao_sinal_verde -= 5
      else:
          self.duracao_sinal_verde += 5
      
      # Limita o tempo de sinal verde entre 10 e 60 segundos
      self.duracao_sinal_verde = max(10, min(self.duracao_sinal_verde, 60))
  
  def iniciar(self):
      while True:
          self.ajustar_sinal()
          print(f"Sinal verde por {self.duracao_sinal_verde} segundos")
          time.sleep(self.duracao_sinal_verde)
          print("Sinal vermelho")
          time.sleep(5)  # Tempo de sinal vermelho fixo

# Criação de duas câmeras em posições diferentes
camera1 = Camera("Interseccao A")
camera2 = Camera("Interseccao B")

# Criação do semáforo inteligente com as câmeras
semaforo_inteligente = SemaforoInteligente([camera1, camera2])

# Execução do semáforo inteligente
semaforo_inteligente.iniciar()

Nesse exemplo, criamos duas classes principais: Camera e SemaforoInteligente. A classe Camera simula a captura de dados de tráfego em uma interseção, enquanto a classe SemaforoInteligente controla a lógica adaptativa do semáforo.

O método ajustar_sinal é o coração do algoritmo. Ele captura informações de todas as câmeras disponíveis e decide se deve aumentar ou diminuir o tempo de sinal verde com base na quantidade de veículos detectados. Isso demonstra a capacidade dos semáforos inteligentes de se adaptarem às condições de tráfego em tempo real.

O método iniciar mantém o funcionamento contínuo do semáforo, imprimindo o tempo de sinal verde, aguardando o período definido e alternando para o sinal vermelho.

5 MÉTODO VERIFICA TRÁFEGO

Reservo este tópico unicamente para o método verifica_trafego. Para realizar a verificação do tráfego desenvolvi este código de exemplo numa imagem estática.

import cv2
from detectron2.engine import DefaultPredictor
from detectron2.config import get_cfg
from detectron2.utils.visualizer import Visualizer
from detectron2.data import MetadataCatalog
from detectron2 import model_zoo

img_path = 'caminho/imagem.jpg'

cfg = get_cfg()
cfg.merge_from_file(model_zoo.get_config_file("COCO-Detection/faster_rcnn_R_50_C4_1x.yaml"))
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("COCO-Detection/faster_rcnn_R_50_C4_1x.yaml")
cfg.MODEL.DEVICE = 'cpu' # Troque para cuda caso você possua uma GPU da NVIDIA
predictor = DefaultPredictor(cfg)

imagem = cv2.imread(img_path)

outputs = predictor(imagem)
instances = outputs['instances']
num_cars = (instances.pred_classes == 3).sum().item()  # O número 3 correspondem aos carros no COCO dataset
print(f'Número de carros detectados: {num_cars}')

v = Visualizer(imagem[:, :, ::-1], MetadataCatalog.get(cfg.DATASETS.TRAIN[0]), scale=1.2)
out = v.draw_instance_predictions(outputs["instances"].to("cpu"))
cv2.imshow('Imagem com Detecções', out.get_image()[:, :, ::-1])
cv2.waitKey(0)
cv2.destroyAllWindows()

Nesse trecho de código, adotamos a abordagem da biblioteca OpenCV (cv2) em conjunto com o framework Detectron2. A OpenCV permite não apenas o acesso à imagem, mas também exibe as visualizações geradas pelo Detectron2, enriquecendo a experiência de análise. Por outro lado, o Detectron2, impulsionado por um modelo de Inteligência Artificial treinado, desempenha um papel crucial na detecção de carros na imagem.

A variável num_cars armazena o número de carros detectados. Esta que seria passada no return da função com este trecho de código, possibilitando o dinamismo do tempo do sinal.

6 CONCLUSÃO

Os semáforos inteligentes estão rapidamente se tornando um símbolo da revolução tecnológica. Essas inovações não apenas agilizam o tráfego, mas também reduzem a emissão de poluentes ao diminuir os congestionamentos, além de garantir mais segurança às vias de maior periculosidade. À medida que a tecnologia por trás dos semáforos inteligentes evolui e se integra a outras soluções de mobilidade urbana, podemos antecipar um futuro onde a movimentação nas cidades seja mais fluida e segura à população.

FONTES

Matéria: https://g1.globo.com/sp/sao-paulo/bom-dia-sp/video/semaforos-inteligentes-comecam-a-ser-testados-em-cruzamentos-da-capital-11880220.ghtml
Foto de Capa: https://br.freepik.com/fotos-gratis/semaforo-verde-durante-a-chuva-carros-passando_17245235.htm#query=sem%C3%A1foro&position=3&from_view=search&track=sph
Algoritmo de Detecção de Carros: https://www.analyticsvidhya.com/blog/2021/12/vehicle-detection-and-counting-system-using-opencv/
Detectron2: https://github.com/facebookresearch/detectron2

---------------

Quero deixar claro que não sou nenhum profissional da área. Eu sou apenas um grande entusiasta da tecnologia. Sintam-se livres para realizar críticas construtivas e pontuações sobre o conteúdo. :)