Introdução ao SUMO

SUMO (Simulation of Urban MObility) é uma ferramenta de código aberto (open source) para simulação microscópica de trânsito. A ferramenta está disponível em http://sumo-sim.org.

Para usuários do sistemas operacional Windows, o link para download se encontra na página inicial no item “Download (for Windows)”. Para usuários Linux, pode ser acessado o item “Download” no menu superior.

Nesse tutorial é explicado como criar uma simulação básica, com a criação de um cruzamento semaforizado e a inclusão de um veículo para percorrer a via criada.

Especificando uma network (rede)

A definição de uma network inicia com a especificação de pontos (nós ou vértices) que serão ligados, conectando-se. Para isso será necessário especificar dois arquivos no formato XML esperado do SUMO, sendo esse o arquivo de nós/pontos (nodes) e o arquivo de ligação/junção (edges).

A Figura abaixo ilustra a rede que ser irá desenvolver inicialmente. Ela é constituída de 3 pontos que são interligados formando 2 ruas. Cada ponto está identificado iniciando com a letra “p” e seguida de um número.

O arquivo de nós para formar a rede é mostrado a seguir e deve ser salvo com a extensão “.nod.xml”. A extensão do nome do arquivo não é obrigatória, mas é recomendado seguir essa convenção na nomenclatura.

<nodes>
  <node id="p1" x="0"   y="0" />
  <node id="p2" x="100" y="0" />
  <node id="p3" x="50"  y="50" />
</nodes>

Cada tag nomeada “node” possui a indicação de um ponto, sendo necessário especificar seu posicionamento no eixos “x” e “y” e um identificar único (id) que permitirá posteriormente identificar o nó para realizar sua ligação com outro nó. Opcionalmente também pode ser fornecido uma coordenada “z” representando uma altura, mostrando que os mapas podem ser especificados em 3D, embora não será abordado nesse material.

Dica: os arquivos do SUMO são escritos utilizando a linguagem XML. Sendo assim, recomendo que seja utilizado algum editor de textos que suporte a escrita de XMLs, como o Notepad++ (http://notepad-plus-plus.org)

Para a ligação dos pontos será utilizado a especificação mostrada a seguir. Cada ligação gerará uma via seguindo do ponto indicado no parâmetro “from” e indo até o ponto indicado em “to”. O parâmetro para essas propriedades é o identificador do nó indicado anteriormente no arquivo de nós (nome dos pontos indicados na propriedade “id” do arquivo anterior).

<edges>
  <edge from="p1" to="p2" id="1to2" />
  <edge from="p2" to="p3" id="2to3" />
</edges>

Criando efetivamente a network (rede)

Tendo especificado os dois arquivos anteriores (arquivo de nós/nodes e de ligações/edges) é possível criar a network, que a junção dos nós e ligação gerando as rede viária. Essa tarefa é feita a partir do executável netconvert, presente na parta “bin” do SUMO. O que será mostrado a seguir é minha recomendação de como fazer o processo de criar a rede. Considero esse o jeito mais simples e que dispensa detalhamentos técnicos. A forma “padrão” encontrada em outros materiais, como a própria documentação, é mais trabalhosa.

Inicialmente, copie os arquivos “netconvert.exe” (dependendo da versão do SUMO que foi baixada, o arquivo se chamará netconvert64.exe) e as DLLs “xerces-c_3_1.dll”, “proj.dll” e “gdal18.dll” para a pasta onde estão sendo salvos os arquivos do projeto. Crie um arquivo com extensão “.netc.cfg” e insira o código a seguir nesse arquivo. Esse arquivo é um arquivo de configuração para o Netconvert e informa qual o nome do arquivo de nós/nodes (está sendo considerado que o nome do arquivo de nós foi salvo como meu.nod.xml), qual o nome do arquivo de ligação/edges (está sendo considerado o nome do arquivo salvo como meu.edg.xml) e também é especificado um nome para o arquivo da rede que será gerada pelo Netconvert (que no caso do arquivo de configuração foi especificado o nome meu.net.xml).

<configuration>
   <input>
       <edge-files value="meu.edg.xml"/>
       <node-files value="meu.nod.xml"/>
   </input>
   <output>
       <output-file value="meu.net.xml"/>
   </output> 
</configuration>

Tendo o arquivo de configuração especificado, basta arrastar o arquivo para cima do Netconvert. Uma janela de fundo preto será rapidamente aberta e um arquivo chamado “meu.net.xml” será criado.

Para testar se a rede foi especificada conforme foi planejado, é possível abrir a network no SUMO e visualizá-la. Faça isso abrindo o sumo a partir do arquivo SUMO-GUI, clique em “file” e depois na opção “open network”, abrindo o arquivo recém criado. O resultado esperado é o apresentado na figura abaixo.

Se o arquivo network não for gerado é que algum erro aconteceu nas especificações. A tela de fundo preto que abriu deve ter mostrado o erro, mas ela se fecha muito rápido. Nesse caso é preciso utilizar o “prompt de comando” (no caso do Windows) ou o terminal (para usuários do Linux). Chamarei ambos de terminal.

No terminal é preciso entrar no diretório onde estão sendo salvos os arquivos do projeto e para onde foi copiado o Netconvert e DLLs necessárias. No terminal digite o comando (sem as aspas) “netconvert –node-files=meu.nod.xml –edge-files=meu.edg.xml –output-file=meu.net.xml”. Preste atenção que o último parâmetro (output-file) está na singular, diferente dos dois anteriores que estão no plural. Repare também que os parâmetros informados são os nomes dos arquivos de nós, ligações e o arquivo da rede que deve ser gerado.

Importante: de um usuário do Linux já é esperado que ele saiba utilizar o terminal. Usuários do Windows podem conferir meu vídeo em https://www.youtube.com/watch?v=PahY1W5_lCc a partir do instante 4:33min, onde demonstro melhor esse processo.

Adicionando mais detalhes a network (rede)

A rede gerada é ainda muito simples, composta de duas ruas de mão única. Para fazer uma rua de mão dupla, é necessário especificar duas ligações, invertendo os valores “from” e “to”. O resultado é mostrado na figura a seguir. A rua na diagonal possui mão dupla com a ligação dos pontos “p2” e “p3” e depois dos pontos “p3” e “p2”. A via na horizontal possui apenas um sentido, indo do ponto “p1” para o “p2”.

<edges>
  <edge from="p1" id="1to2" to="p2" />
  <edge from="p2" id="2to3" to="p3" />
  <edge from="p3" id="3to2" to="p2" />
</edges>

Um detalhe importante é que qualquer modificação feita no arquivo de nós e edges precisa com que seja executado o Netconvert novamente, afinal é o arquivo de rede (network) que é aberto no SUMO. Sendo assim, siga os passos já vistos do uso do Netconvert e só depois abra a rede no SUMO.

Criando um cruzamento

Inicialmente a tentativa de criar um cruzamento seria criar um novo ponto (p4, na coordenada 50,-40) e um novo edge ligando o ponto “p3” com o novo ponto. As especificações abaixo para os nós e edges correspondem a figura a seguir. O cruzamento que se pretendia criar está demarcado pelo círculo pontilhado.

Código dos nós (adição da linha 5 com relação a especificação anterior):

<nodes>
  <node id="p1" x="0"   y="0" />
  <node id="p2" x="100" y="0" />
  <node id="p3" x="50"  y="50" />
  <node id="p4" x="50"  y="-40" />
</nodes>

Código dos edges (adição da linha 5 com relação a especificação anterior):

<edges>
  <edge from="p1" id="1to2" to="p2" />
  <edge from="p2" id="2to3" to="p3" />
  <edge from="p3" id="3to2" to="p2" />
  <edge from="p3" id="3to4" to="p4" />
</edges>

A forma especificada não cria efetivamente o cruzamento, sendo essa uma maneira incorreta. A seguir mostro como criar corretamente o cruzamento, mas se você gerar a rede, ao abrir no SUMO você verá o resultado mostrado abaixo. Você pode estranhar ver as partes marcadas com o círculo pontilhado, mas isso não é problema e a rede está correta. A aparência estranha é apenas um defeito visual e não pode ser corrigido.

Para criar corretamente o cruzamento é preciso que o cruzamento possua mais um nó, como é mostrado na figura abaixo e especificado a seguir.

Código dos nós:

<nodes>
  <node id="p1" x="0"   y="0" />
  <node id="p2" x="100" y="0" />
  <node id="p3" x="50"  y="50" />
  <node id="p4" x="50"  y="0" />
  <node id="p5" x="50"  y="-40" />
</nodes>

Código dos edges:

<edges>
  <edge from="p1" id="1to4" to="p4" />
  <edge from="p4" id="4to2" to="p2" />
  <edge from="p2" id="2to3" to="p3" />
  <edge from="p3" id="3to4" to="p4" />
  <edge from="p4" id="4to5" to="p5" />
</edges>

Observe que o arquivo de nós apenas precisou adicionar mais um nó, mas que o arquivo de edges precisou de mais especificações, sendo necessário ligar o primeiro ponto ao cruzamento e o cruzamento ao final daquela via. Sendo assim a especificação do que seria uma rua precisa ser especificado por suas partes (no caso, duas partes: antes do cruzamento e depois do cruzamento).

Ao gerar a nova rede o resultado é o mostrado a seguir. O resultado pode parecer um pouco estranho, mas é que o cruzamento é de duas vias de mão única. No tópico a seguir, sobre semáforo, será mostrado a adição de duas mãos e o cruzamento parecerá mais “normal”. Observe pela setas que o SUMO já determina as direções possíveis de se seguir através das setas.

Lembre-se de a cada vez que alterar os nós ou edges, é preciso gerar novamente a rede.

Implantando um semáforo

Semáforos podem ser colocados em qualquer nó e o SUMO irá gerar automaticamente sua programação semafórica e os veículos sempre a irão respeitar. Os nós que precisam ter um semáforo deve ser alterados adicionando o parâmetro type=”traffic_light”, conforme exemplificação no código a seguir.

<nodes>
  <node id="p1" x="0"   y="0" />
  <node id="p2" x="100" y="0" />
  <node id="p3" x="50"  y="50" />
  <node id="p4" x="50"  y="0" type="traffic_light" />
  <node id="p5" x="50"  y="-40" />
</nodes>

Segundo a especificação, o ponto “p4” passou a conter um semáforo. A parte a esquerda da figura abaixo ilustra o resultado obtido no cruzamento. Em posterior funcionamento da simulação, será possível observar os sinais se alterarem e os veículos obedecerem o semáforo. A parte a direita da figura mostra o cruzamento obtido com a adição de mais uma mão na via horizontal especificada.

Com relação a adição da nova mão na via que possui um cruzamento, esse deve ser cuidado pois, assim como foi ligado o ponto “p1” com o ponto “p4” do cruzamento, será necessário fazer as ligação contrárias, no caso, ligando o “p4” com o “p1” e a ligação entre “p4” e “p2” precisa ser complementada com uma ligação entre “p2” e “p4”, conforme código de edges a seguir.

<edges>
  <edge from="p1" id="1to4" to="p4" />
  <edge from="p4" id="4to1" to="p1" />
  <edge from="p4" id="4to2" to="p2" />
  <edge from="p2" id="2to4" to="p4" />
  <edge from="p2" id="2to3" to="p3" />
  <edge from="p3" id="3to4" to="p4" />
  <edge from="p4" id="4to5" to="p5" />
</edges>

Adicionando veículos

Até o momento o que se obteve nas especificações é a elaboração da malha viária, sem qualquer veículo fazendo uso dessa. Os passos seguintes consistem em adicionar veículos fazendo certo percurso nas vias especificadas. Sendo assim, a adição de veículos depende da elaboração de rotas e de que veículos atuarão na rota definida. A especificação a seguir deve ser salva com a extensão “.rou.xml”.

O primeiro passo para criar a rota é especificar um tipo de veículo. A segunda linha da especificação abaixo realiza isso utilizando a tag “vType”. Nela são especificadas as aceleração (accel), desaceleração (decel) e velocidade máxima que o veículo irá alcançar, utilizando a unidade de metros por segundo (m/s). O parâmetro “id”, assim como visto na especificação de nós e edges, servirá para identificar esse tipo de veículo. Também está sendo definido um tamanho (length) que o veículo deverá ter largura, definido em metros. Todos os tipos de veículos que irão transitar nas vias deveria estar especificado através dessa tag.

Definido um tipo de veículo, o próximo passo é especificar as rotas (caminhos) que os veículos irão fazer. Na especificação a seguir apenas uma rota foi definida, mas na prática deverão ser especificadas diversas rotas especificando os caminhos que os veículos irão fazer na simulação. A rota é definida pela tag “route” e é composta por um identificador (id) único e o parâmetro edges, que é o nome especificados para os edges e separados por espaço.

Para finalizar é especificado realmente o veículo, que deverá ser de um tipo e trafegar em uma rota. A linha 4 da especificação das rotas é responsável por essa especificação. O primeiro parâmetro (type) define de qual tipo é o veículo (que no caso da especificação é identificado por “Car”) e a rota (route) do veículo (definida como “rotaO”). Também é especificado um identificador para o veículo especificado através da tag “id” e finalizando com a especificação apresentada na tag “depart”, onde é especificado em que tempo da simulação o veículo será gerado, que no caso significa logo ao início da simulação.

<routes>
  <vType accel="2" decel="4" maxSpeed="20" id="Car" length="5" />
  <route id="rota0" edges="1to2 2to3" />
  <vehicle type="Car" route="rota0" id="carro1" depart="1" />
</routes>

Ao simular, observe que na rota especificada, o veículo não percorre toda a via, desaparecendo no nó final que compõe a via. Para fazer um trajeto que percorra toda a via seria preciso especificar outra rota e fazer o veículo trafegar por ela. Mais adiante é mostrado como realizar tal ação.

Criando um arquivo de configuração

Temos agora o último arquivo que precisa ser especificado para conseguir executar a simulação. Ele é um arquivo que configura que arquivos serão utilizados para a simulação, sendo o arquivo de configuração o responsável por associar os arquivo da network e da rota especificados. A especificação abaixo gera a configuração e deve ser salva com a extensão .sumocfg.

<configuration>
  <input>
    <net-file value="meu.net.xml"/>
    <route-files value="meu.rou.xml"/>
  </input>
</configuration>

Basicamente precisamos fornecer no parâmetro “value”, o nome dos arquivos de especificação gerados da network e da rota. Eles são obrigatórios. Uma forma simplificada de escrever o arquivo de configuração é mostrada a seguir, mas faz exatamente a  mesma coisa.

<configuration>
  <n v="meu.net.xml"/>
  <r v="meu.rou.xml"/>
</configuration>

Vale lembrar que os arquivos de nós e edges não são necessários na especificação pois eles foram utilizados na geração do arquivo de rede (meu.net.xml).

Agora sim é possível executar a simulação e acompanhar todo o esforço na especificação dos arquivos realizados.

Executando uma simulação

Tendo finalizado o arquivo de configuração é possível abrir a interface do SUMO executando o arquivo sumo-gui.exe (), que fica dentro da pasta “bin” de onde o SUMO foi descompactado, e indo na opção “file”, e em seguida “open”, localizando o arquivo de configuração recém gerado.

A interface do SUMO é bastante simples, sendo composta basicamente dos controles da simulação. De importante destacam-se os ícones que serão relacionados a seguir e o display do “Time” que mostra o avanço dos instantes da simulação.

Para executar a simulação é utilizando o botão play () e é interessante também alterar o tempo de delay (). A simulação acontece em ciclos não baseados em tempo, sendo a configuração de delay uma forma conseguir acompanhar a simulação. Se o delay for configurado para 1000, entre cada ciclo será dado 1 segundo, gerando uma simulação próxima do tempo real.

Para uma primeira visualização, configure o delay para 1000 e clique em play, acompanhando o carro gerado e seu trajeto. Quando o último carro presente na pista finalizar sua rota e nenhum outro carro estiver especificado para iniciar, a simulação será dada por encerrada. Para reexecutá-la clique no botão de reload () e de novamente play.

Isso encerra o básico da utilização do SUMO. Para simulação é possível aumentar a complexidade da rede viária, inclusão de diferentes tipos de veículo e rotas, configuração dos tempos semafóricos, entre outras opções avançadas que serão exploradas posteriormente.

Artigos complementares

Veja mais informações sobre criação de simulação  utilizando o SUMO acessando os materiais adicionais disponíveis no blog, que seguem:

• Gerar diversas rotas, tipos de veículo e veículos no SUMO