Escolar Documentos
Profissional Documentos
Cultura Documentos
CURITIBA
2007
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ
CURITIBA
2007
Cesar Eduardo Kaoru Arruda
Flávio Moisés de Araújo
Banca Examinadora
iii
RESUMO
iv
ABREVIATURAS, SIGLAS E ACRÔNIMOS
v
SUMÁRIO
RESUMO.................................................................................................................iv
ABREVIATURAS, SIGLAS E ACRÔNIMOS .......................................................... v
SUMÁRIO ...............................................................................................................vi
ÍNDICE DE FIGURAS ........................................................................................... viii
ÍNDICE DAS TABELAS.......................................................................................... x
1. INTRODUÇÃO .................................................................................................... 1
1.1 TEMA ................................................................................................................ 1
1.2 JUSTIFICATIVAS DO PROJETO...................................................................... 2
1.3 OBJETIVOS ...................................................................................................... 5
1.3.1 Criação do Site WAP...................................................................................... 5
1.3.2 Desenvolvimento de um Algoritmo de Roteirização ....................................... 5
1.3.3 Sistema eficiente e simples ............................................................................ 6
1.4 REQUISITOS DO SISTEMA ............................................................................. 7
1.5 FUNCIONAMENTO DO SISTEMA.................................................................... 8
2. ESPECIFICAÇÃO DO SISTEMA...................................................................... 10
2.1 DIAGRAMA DE CASOS DE USO ................................................................... 10
2.2 MODELO DE DADOS ..................................................................................... 11
2.2.1 Modelo Entidade Relacionamento................................................................ 11
2.2.2 Dicionário de Dados ..................................................................................... 13
2.3 LEVANTAMENTO DE CLASSES.................................................................... 15
2.4 DIAGRAMA DE CLASSES.............................................................................. 16
2.5 DIAGRAMA DE SEQÜÊNCIA ......................................................................... 17
3. TECNOLOGIAS E ALGORITMOS ................................................................... 20
3.1 JSP E SERVLETS........................................................................................... 20
3.2 TOMCAT ......................................................................................................... 21
3.3 POSTGRESQL E PGADMIN........................................................................... 21
3.4 WAP ................................................................................................................ 22
3.5 WML E WMLSCRIPT ...................................................................................... 23
3.6 NOKIA MOBILE INTERNET TOOLKIT (NMIT) ............................................... 24
vi
3.7 ALGORITMO DE DIJKSTRA........................................................................... 24
3.8 ALGORITMO DE FLOYD-WARSHALL ........................................................... 25
4. FERRAMENTAS DE DESENVOLVIMENTO .................................................... 27
4.1 ARQUITETURA DO SISTEMA........................................................................ 27
4.2 WML E JSP ..................................................................................................... 28
4.3 SERVLET ........................................................................................................ 30
4.4 WAP ................................................................................................................ 32
5. ANÁLISE DOS ALGORITMOS......................................................................... 36
5.1 EXEMPLO DE GERAÇÃO DE BANCO E CÁLCULO DE ROTEIRIZAÇÃO.... 36
5.1.1 Geração do banco de dados e roteirização: Floyd-Warshall ........................ 37
5.1.2 Geração do banco de dados e roteirização: Dijkstra.................................... 39
5.1.3 Geração do banco de dados e roteirização: BuscaCuritiba.......................... 42
5.2 CASOS DE TESTES ....................................................................................... 42
6. DESENVOLVIMENTO DO SISTEMA ............................................................... 48
6.1 INTERAÇÃO INICIAL COM O USUÁRIO........................................................ 48
6.2 ALGORITMOS ................................................................................................ 50
6.3 COMENTÁRIOS SOBRE O DESENVOLVIMENTO........................................ 55
6.3.1 Codificação dos Caracteres ......................................................................... 55
6.3.2 Limitação de Hardware................................................................................. 56
6.3.3 Levantamento dos Dados............................................................................. 56
6.3.4 Cache nas Páginas WAP ............................................................................. 57
6.3.5 Cronograma do Projeto ................................................................................ 57
7. CONCLUSÃO ................................................................................................... 59
REFERÊNCIAS..................................................................................................... 61
APÊNDICE A: CÓDIGO DA PÁGINA INDEX.JSP............................................... 63
APÊNDICE B: IMPLEMENTAÇÃO DO ALGORITMO DE FLOYD-WARSHALL. 65
APÊNDICE C: IMPLEMENTAÇÃO DO ALGORITMO DE DIJKSTRA................. 69
vii
ÍNDICE DE FIGURAS
viii
Figura 27: Página informando que os endereços não foram encontrados ............ 49
Figura 28: Página de confirmação dos dados ....................................................... 49
Figura 29: Página com o resultado da roteirização ............................................... 50
Figura 30: Pseudo-código do Algoritmo de Rotas a Pé......................................... 51
Figura 31: Exemplo gráfico de uma rota do Alg. Para Carros ............................... 52
Figura 32: Pseudo-código de parte do Algoritmo Para Ônibus ............................. 54
Figura 33: Cronograma idealizado no pré-projeto (à esquerda) e cronograma
realizado (à direita) ............................................................................................ 58
ix
ÍNDICE DAS TABELAS
x
1
1. INTRODUÇÃO
1.1 TEMA
Empresa Origem Recursos Produto Custo Site WAP / Ônibus A Carro Curitiba
Necessários Software pé
1.3 OBJETIVOS
minimização do custo de travessia de um grafo entre dois nós (ou vértices); custo
este dado pela soma dos pesos de cada aresta percorrida.” [SAMPAIO e
YANASSE]
O desenvolvimento de Algoritmos de Roteirização já é bastante conhecido e
estudado, sendo que existem vários algoritmos famosos, como o Algoritmo de
Dijkstra, o Algoritmo de Bellman-Ford, o Algoritmo A* (lê-se A estrela), o Algoritmo
de Floyd-Warshall, o Algoritmo de Johnson entre outros.
Além da implementação e comparação entre dois desses algoritmos já
conhecidos, uma parte do projeto consiste no desenvolvimento de um ou mais
tipos de algoritmos para calcular os menores ou melhores (conforme o caso)
caminhos entre as esquinas do bairro Centro de Curitiba.
As comparações entre os dois algoritmos selecionados e o novo algoritmo
criado servem para mostrar a eficiência dos mesmos, relacionando parâmetros
como o tempo de execução para o cálculo da rota e a distância percorrida pela
rota calculada.
2. ESPECIFICAÇÃO DO SISTEMA
através da figura 5.
A classe Roteiriza é o núcleo do sistema, sendo a responsável direta pelos
cálculos que resultam na rota desejada. Como será mostrado no próximo item,
todo o processo começa quando a DesenhaFormulario recebe os dados e faz uma
chamada aos métodos da Roteiriza. Nesse momento as demais classes são
utilizadas, seja para acessar o banco de dados ou para formatar a resposta
enviada para o usuário.
O fluxo de ações dos dois casos de usos descritos no item 2.1 pode ser
representado através dos diagramas de seqüência das figuras 6 e 7, a seguir. No
primeiro caso de uso, no qual o administrador do sistema gerencia os dados
armazenados no banco de dados, a classe AtualizaBD (descrita no item 2.3) é
utilizada para incluir, excluir ou alterar as informações, conforme as necessidades
do administrador.
18
No caso de uso em que o usuário busca uma rota, as demais classes são
utilizadas. Primeiramente, a classe DesenhaFormulario desenha a tela inicial e
aguarda o usuário inserir os dados. Feita essa inserção, os dados são enviados
para a Roteiriza analisar. Se um erro ocorrer, por exemplo, algum campo
obrigatório do formulário permaneceu em branco, a DesenhaFormulario recebe
uma notificação do erro. Senão, a AcessaBD é utilizada para buscar os dados no
banco e retornar o que encontrou. O retorno é enviado para a Roteiriza, que trata
esses dados e envia para a DesenhaFormulario mostrar ao usuário o que foi
encontrado. Assim que o usuário confirma as informações, a DesenhaFormulario
novamente envia os dados para a Roteiriza, que novamente utiliza a AcessaBD,
mas agora para obter o caminho entre o destino e origem passados e confirmados
pelo usuário. Após ter encontrado esse caminho, a Roteiriza usa a FormulaString
para formatar os dados em um formato compreensível pelo usuário, e, então,
retorna essas indicações geográficas para a DesenhaFormulario mostrar ao
usuário.
19
3. TECNOLOGIAS E ALGORITMOS
Neste item está uma descrição sucinta de cada uma das tecnologias,
softwares e algoritmos utilizados durante o desenvolvimento do projeto. Outras
informações podem ser encontradas nas fontes originais, indicadas nas
referências bibliográficas.
No item ‘Ferramentas de Desenvolvimento’ as tecnologias aqui descritas
são contextualizadas no projeto, mostrando quais as suas funções e onde se
encaixam na arquitetura do sistema desenvolvido.
3.2 TOMCAT
3.4 WAP
/* V[G] é o conjunto de vértices(v) que formam o Grafo G. d[v] é o vetor de distâncias de s até cada v. Admitindo-se a
pior estimativa possível, o caminho infinito. π[v] identifica o vértice de onde se origina uma conexão até v de maneira a
formar um caminho mínimo.*/
// 2º passo: temos que usar dois conjuntos: S, que representa todos os vértices v onde d[v] já contém o custo do menor
caminho e Q que contém todos os outros vértices.
//3º passo: realizamos uma série de relaxamentos das arestas, de acordo com o código:
enquanto Q ≠ ø
u ← extraia-mín(Q)
S ← S {u}
para cada v adjacente a u
se d[v] > d[u] + w(u, v) //relaxe (u, v)
então d[v] ← d[u] + w(u, v)
π[v] ← u
/* w(u, v) é o peso(weight) da aresta que vai de u a v. u e v são vértices quaisquer e s é o vértice inicial.
extraia-mín(Q), pode ser um heap de mínimo ou uma lista ordenada de vértices onde obtém-se o menor elemento, ou
qualquer estrutura do tipo.*/
4. FERRAMENTAS DE DESENVOLVIMENTO
4.3 SERVLET
Foram criadas três servlets para receber os dados passados pelo usuário e
gerar a rota, cada uma responsável por um determinado tipo de roteirização. Após
inicializadas no servidor Tomcat, as servlets respondem às requisições dos
clientes com o texto informativo da rota a ser percorrida. Cada servlet é dividida
em dois algoritmos: um para descobrir o melhor caminho entre os pontos
passados e o outro para criar a resposta apresentada para o usuário.
A geração da resposta segue o mesmo padrão da geração de saída HTML
31
simples típica das servlets Java, salvo algumas adaptações para abrigar o
conteúdo formatado nas regras da linguagem WML. Para enviar uma resposta ao
cliente, é inserida no código uma chamada ao método getWriter do objeto da
classe HttpServletResponse, que retorna uma referência a um objeto da classe
PrintWriter. Essa classe é a responsável pelo encapsulamento de streams
utilizados para a transmissão de dados do tipo texto e, por essa razão, deve ser
utilizada para enviar informações ao requisitante.
Abaixo um exemplo ilustrativo da explicação do parágrafo anterior.
response.setContentType("text/vnd.wap.wml");
out.println("<?xml version='1.0'?><!DOCTYPE wml PUBLIC '-
//WAPFORUM//DTD WML 1.1//EN'
'http://www.wapforum.org/DTD/wml_1.1.xml'>");
out.println("<wml>”);
//código
out.println(“</wml>”);
4.4 WAP
1 2 3 4 5 1 2 3 4 5
1 0 1 2 5 2 1 0 0 2 0 2
2 9999 0 1 9999 1 2 0 0 0 0 0
3 9999 9999 0 9999 5 3 0 0 0 0 0
39
4 1 2 3 0 1 4 0 1 1 0 0
5 9999 9999 9999 1 0 5 0 0 0 0 0
1 2 3 4 5 1 2 3 4 5
1 0 1 2 5 2 1 0 0 2 0 2
2 9999 0 1 9999 1 2 0 0 0 0 0
3 9999 9999 0 9999 5 3 0 0 0 0 0
4 1 2 3 0 1 4 0 1 1 0 0
5 9999 9999 9999 1 0 5 0 0 0 0 0
1 2 3 4 5 1 2 3 4 5
1 0 1 2 5 2 1 0 0 2 0 2
2 9999 0 1 9999 1 2 0 0 0 0 0
3 9999 9999 0 9999 5 3 0 0 0 0 0
4 1 2 3 0 1 4 0 1 1 0 0
5 2 3 4 1 0 5 4 4 4 0 0
1 2 3 4 5 1 2 3 4 5
1 0 1 2 3 2 1 1 2 2 2 2
2 3 0 1 2 1 2 5 2 3 5 5
3 7 8 0 6 5 3 5 5 3 5 5
4 1 2 3 0 1 4 1 1 1 4 5
5 2 3 4 1 0 5 4 4 4 4 5
diferença que ele trabalha com vetores e não matrizes, por ter como objetivo achar
o menor caminho de um ponto para qualquer outro do grafo, e não de qualquer
ponto para qualquer outro.
Inicialmente, define-se qual será o vértice raiz. O vetor inicial contém os
valores das distâncias de todos os outros vértices até o vértice-raiz, sendo que o
valor para os vértices que não fazem ligação direta com o raiz é definido como
infinito (ou um valor muito alto). Conforme o algoritmo é executado, dois vetores
são utilizados para guardar as distâncias e os caminhos mínimos entre os demais
vértices e o vértice-raiz.
distância desse novo vértice até o nó-cinza. É somada essa distância com a
distância entre o nó-cinza e o nó-raiz, e essa é a distância que será gravada no
vetor de menores distâncias.
1 2 3 4 5 1 2 3 4 5
1 0 1 2 5 2 1 1 1 2 1 2
1 2 3 4 5 1 2 3 4 5
1 0 1 2 5 2 1 1 1 2 1 2
1 2 3 4 5 1 2 3 4 5
1 0 1 2 3 2 1 1 1 2 5 2
1 2 3 4 5 1 2 3 4 5
1 0 1 2 3 2 1 1 1 2 5 2
traçará uma rota e, como resposta, exibem qual foi a rota calculada, o tempo de
execução dos cálculos e qual a distância percorrida.
Foram traçadas 15 rotas distintas entre si pela distância percorrida e
anotados os tempos de execução em milissegundos gastos pelos três algoritmos
para o cálculo de cada rota, a distância percorrida, que não recebe uma unidade
de medida por se tratar da distância entre dois pontos calculada pela fórmula da
geometria analítica, e o número de quadras que compõem a rota traçada.
Uma observação importante é que os testes foram realizados em acessos
exclusivos, ou seja, os gráficos, a seguir apresentados, representam a atuação de
cada algoritmo sendo requisitado por um único cliente.
As 15 rotas foram escolhidas por representarem todas as possibilidades de
caminhos: origem e destino iguais; origem e destino na mesma quadra; origem e
destino na mesma rua; origem e destino em distâncias pequenas; e origem e
destino em distâncias grandes. Os pontos foram selecionados de maneira a
explorar a maior parte possível das ruas disponíveis.
Os dados coletados basearam os três gráficos a seguir, que relacionam os
15 casos da amostragem, primeiramente, com o tempo de execução dos três
algoritmos, em seguida, com as distâncias percorridas pelas rotas calculadas, e,
por último, com a quantidade de quadras percorridas pelas rotas calculadas.
Para uma melhor análise os 15 casos foram ordenados pela distância entre
as coordenadas de origem e de destino. Dessa maneira, o caso 1 representa o
caso em que origem e destino estão mais próximos e o caso 15 em que estão
mais distantes.
Relacionando os casos com o tempo de execução dos algoritmos (Figura
23), nota-se que o algoritmo BuscaCuritiba demanda mais tempo de execução
conforme se aumenta a distância entre origem e destino. Em contrapartida, o
algoritmo de Dijkstra demonstra regularidade nos tempos dispendidos por suas
rotas calculadas, apresentando uma média de aproximadamente 300
milissegundos em cada caso. O algoritmo de Floyd-Warshall apresenta os tempos
mais elevados em 7 casos e o tempo mais elevado de todos: 688 milissegundos.
44
800
700
600
500
Tempo (ms)
Busca Curitiba
400 Floyd-Warshall
Dijkstra
300
200
100
0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Casos
700
600
500
Floyd-Warshall
300 Dijkstra
200
100
0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Casos
Figura 24: Gráfico de comparação das distâncias percorridas pelas rotas dos algoritmos
45
30
25
20
Busca Curitiba
Quadras
15 Floyd-Warshall
Dijkstra
10
0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Casos
Figura 25: Gráfico de comparação das quadras percorridas pelas rotas dos algoritmos
Com base nos resultados obtidos e nas observações dos gráficos conclui-
se que o algoritmo de BuscaCuritiba é mais eficiente em termos de tempo de
execução que o algoritmo de Floyd-Warshall na maioria dos casos. Em relação ao
algoritmo de Dijkstra, o BuscaCuritiba apresenta maior eficiência até certo ponto,
pois à medida em que se aumenta a distância entre os pontos de origem e destino
da rota, o algoritmo demanda maior tempo de execução.
Na amostragem utilizada para as comparações, o Dijkistra torna-se mais
eficiente a partir do momento em que as distâncias entre os pontos de origem e
destino da rota atinge o valor de 700. Isso se deve ao fato de o algoritmo de
BuscaCuritiba repetir uma cadeia de comandos em um laço while a cada quadra
adicionada à rota. Assim sendo, o algoritmo torna-se mais dispendioso à medida
46
6. DESENVOLVIMENTO DO SISTEMA
6.2 ALGORITMOS
// busca, entre as duas esquinas de origem, qual está mais próxima do destino
esquina_o = buscarMaisProxima();
f = 0;
rota[f] = esquina_o;
enquanto (rota[f] for diferente de destino) {
// busca os vizinhos da esquina
vizinhos[] = buscaVizinhos(rota[f]);
// ordena os vizinhos por ordem de proximidade com o destino
vizinhos[] = ordenarVetor(vizinhos);
f++;
rota[f] = vizihnos[0];
}
// a rota está guardada no vetor rota[]
O “Algoritmo Para Carros” foi projetado para encontrar a melhor rota entre a
origem e o destino, portanto não é o seu objetivo encontrar o menor caminho.
Para roteirizar para carros deve-se levar em consideração o sentido das ruas,
contudo outras observações devem ser feitas para que o roteirizador aja como se
fosse um motorista seguindo o fluxo do trânsito. Para tanto, o algoritmo foi
desenvolvido para encontrar a rota que utilize um número menor de ruas,
seguindo pela maior distância possível na mesma rua. O seu funcionamento é o
seguinte: primeiro encontram-se os dois melhores vizinhos (mais próximos do
destino) da esquina atual (Alfa e Beta); verifica-se se Alfa está em alguma das
ruas de alguma das esquinas de destino e se pode alcançá-las através dessa rua;
se sim, Alfa é o melhor caminho e o roteirizador irá encontrar a rota a partir de
Alfa; se não, faz a mesma verificação para Beta, seguindo a mesma lógica. Não
estando nem Alfa e nem Beta em alguma das ruas do destino, segue o algoritmo.
Pegam-se todos os vizinhos de Alfa, um a um, e verifica-se se esse novo vizinho
está em alguma das ruas do destino. A verificação é feita em todos os vizinhos de
52
Alfa que estejam em alguma das ruas que Alfa está, ou seja, quando a rua termina
ou muda de nome, descarta-se os vizinhos seguintes. A operação se repete para
o Beta. No final, se através de Alfa ou Beta consegue-se chegar até o destino
diretamente através de alguma esquina em alguma das ruas em que se
encontram Alfa e Beta, verifica-se a distância que deverá ser percorrida para
seguir para cada um dos caminhos (de Alfa e de Beta) e escolhe-se o menor entre
eles. Se não encontrou rua diretamente ligada a alguma das ruas de destino
seguindo o procedimento descrito, pega-se Alfa e retorna ao começo do algoritmo,
ou seja, pegam-se os dois melhores vizinhos de Alfa, o novo Alfa e o novo Beta e
começa tudo de novo.
// achar DESTINO
// achar ORIGEM
Vector getOrigem(id_destino) {
contaPtsIni_O será 9. */
2) no momento em que pega o ponto verifica se este possui conexão direta
com o destino, só então pega o próximo
3) se (o ponto buscado tiver conexão direta) {
fim = true; //fim;
}
4) senão {
coloca o ponto no vector onibusVect;
}
/* Obs.: talvez seja preciso ordenar o vector onibusVect por ordem de
proximidade ponto->usuário no final da busca dos numPtsIni_O pontos.
Obs2.: os pontos serão guardados da seguinte forma no vector:
"id_ponto,pai". Nesse formato, o id_ponto é o id buscado no banco de
dados e o pai é uma marcação para posteriormente saber quais ônibus foram
pegos para chegar no destino. Para os pontos iniciais o pai deverá ir com
o valor -1. */
5) /* se chegou até aqui é porque o usuários irá utilizar no mínimo 2
ônibus */
ponteiro = contaPtsIni_O
6)
while (!fim) {
6.1 - incluir no vector onibusVect todos os vizinhos do ponto que
está na posição ponteiro do vector onibusVect.
/* Obs.: como nos pontos iniciais, incluir assim: "id_ponto,pai",
sendo que aqui o pai será o valor de ponteiroPai. */
6.2 - antes de incluir, verificar se o ponto já está no vector, se
sim, não inclui. O numDeViz vai recebendo o número de pontos vizinhos
encontrados, como o contaPtsIni_O no começo.
6.3 - for (int cont = ponteiro; cont < (ponteiro + numDeViz); cont++)
{
/* verifica se o ponto que está na posição cont no vector
onibusVect tem conexão direta */
se (tem conexão direta) {
fim = true;
// fim;
/* para saber qual a rota usada, deverá fazer: pegar o
valor do pai desse ponto no vector onibusVect e se esse valor for
diferente de -1, pegar o pai do pai, repetindo esse procedimento até
encontrar o valor -1. Guardar todos os valores no vector rotaFinalVect.
*/
/* colocar no índice 1 do vector rotaFinalVecta o número
de ônibus usados e no índice 2 a distância percorrida. */
}
}
ponteiroPai++;
ponteiro = (ponteiro + numDeViz);
fim = false;
}
return rotaFinalVect;
}
utilizar o algoritmo que irá informar o caminho que deverá ser seguido.
O “Algoritmo Informante” funciona da seguinte forma: pega-se o vetor que
foi utilizado para guardar os pontos (esquinas) pelo algoritmo de roteirização
utilizado; um novo vetor irá guardar o nome da quadra entre o ponto 01 e o ponto
02 do vetor, depois entre o ponto 02 e o ponto 03, e assim até guardar o nome de
todas as quadras (nome das ruas) por onde a rota passa; a mensagem que será
enviada para o usuário é formada lendo-se as quadras que foram gravadas no
vetor, por exemplo, “Inicie pela Avenida Sete de Setembro por 3 quadras até o
número 3555, siga pela Avenida Marechal Floriano...”. O número de quadras é
obtido observando a repetição do nome da quadra em uma seqüência do vetor.
Os números são obtidos através do próprio vetor com as quadras, uma vez que
quando a quadra é gravada no vetor sua numeração é guardada junta.
7. CONCLUSÃO
REFERÊNCIAS
ARAÚJO, Jário. Desenvolvendo para WAP com WML. 2001. Rio de Janeiro:
Editora Ciência Moderna.
BASHAM, Bryan. Use a Cabeça! Servlet & JSP. 2005. Editora Alta Books.
FORTA, Ben et al. Desenvolvendo WAP com WML e WMLScript. Traduzido por:
Daniela Lacerda, Sônia Milione, Valéria Chamon. 2000. Rio de Janeiro: Campus.
NOKIA. Nokia Mobile Internet Toolkit - Versão 4.1 - User’s Guide. 2004.
<wml>
<card id="card1" ontimer="#card2" title="BuscaCuritiba">
<timer value="20"/>
<p align="center">
<br/><br/>Procurando alguma coisa em Curitiba?
</p>
</card>
<card id="card2" ontimer="#card3" title="BuscaCuritiba">
<timer value="30"/>
<p align="center">
<br/><br/><big>BuscaCuritiba</big>
</p>
</card>
<card id="card3" title="BuscaCuritiba">
<p>
<anchor>
iniciar <go href="#card4"/>
</anchor><br/>
<anchor>
ajuda <go href="#card4"/>
</anchor><br/>
<anchor>
outras informações <go href="#card4"/>
</anchor><br/>
<anchor>
fale conosco <go href="#card4"/>
</anchor><br/>
</p>
</card>
<card id="card4" title="BuscaCuritiba">
<onevent type="onenterforward">
<refresh>
<setvar name="origem" value=""/>
<setvar name="destino" value=""/>
<setvar name="num_origem" value=""/>
<setvar name="num_destino" value=""/>
<setvar name="tipo_roteirizador" value=""/>
</refresh>
</onevent>
<onevent type="onenterbackward">
<refresh>
<setvar name="origem" value=""/>
<setvar name="destino" value=""/>
64
<table border="1">
<tr>
<td>
Origem: <br/>
<input name="origem" size="15"/><br/>
n°: <input name="num_origem" size="5" format="5N"/><br/>
</td>
</tr>
<tr>
<td>
Destino: <br/>
<input name="destino" size="15"/><br/>
n°: <input name="num_destino" size="5" format="5N"/><br/>
</td>
</tr>
<tr>
<td>
<select name="tipo_roteirizador">
<option value="1">A pé</option>
<option value="2">De carro</option>
<option value="3">De Ônibus</option>
</select>
</td>
</tr>
<tr>
<td>
<br/>
<anchor>
[buscar]
<go href="jsp/confirma.jsp" method="post">
<postfield name="origem" value="$(origem)"/>
<postfield name="destino" value="$(destino)"/>
<postfield name="num_origem" value="$(num_origem)"/>
<postfield name="num_destino" value="$(num_destino)"/>
<postfield name="tipo_roteirizador" value="$(tipo_roteirizador)"/>
</go>
</anchor>
<anchor>
[voltar]
<go href="#card3"/>
</anchor>
</td>
</tr>
</table>
</card>
</wml>
65
public FloydWarshall() {
Banco = new ConexaoBD();
inicializarValores();
inicializarMatriz();
// só descomentar essas funções se não for usar o banco de dados
//popularMatriz();
//gerarMatrizInfinito();
//gerarMatrizFinal();
//converterVertice(175, 212);
// só descomentar a função inserirNoBanco se quiser gerar uma nova base!
//inserirNoBanco();
gerarRota(205, 254);
calcularDistanciaPercorrida();
}
}
System.out.println("\nTempo de execução: "+tempo);
}
try {
Banco.rs1 = Banco.stat1.executeQuery(declar);
67
while (Banco.rs1.next()) {
Esquinas[cont] = Banco.rs1.getInt("id_esquina");
cont++;
}
Banco.rs1.close();
}
catch (Exception e){
System.out.println(e);
}
try {
for (int cont2 = 0; cont2 < n; cont2++) {
declar = "SELECT * FROM esquinas_vizinhos_ape WHERE id_esquina = "+Esquinas[cont2];
Banco.rs1 = Banco.stat1.executeQuery(declar);
while (Banco.rs1.next()) {
// pegando os vizinhos
viz = Banco.rs1.getInt("viz");
// calculando a distancia até esse vizinho
vertice = converterVertice2(viz);
System.out.println("Viz="+viz+" Vertice="+vertice);
C[cont2][vertice] = calc.getDistancia(Esquinas[cont2], viz);
}
}
Banco.rs1.close();
}
catch (Exception e){
System.out.println(e);
}
}
System.out.print(Rota[cont2]+" ");
}
System.out.println("\nDistância percorrida: "+distancia);
}
public Dijkstra() {
Banco = new ConexaoBD();
inicializarValores();
inicializarMatriz();
popularMatrizBD();
converterVertice(254, 205); //destino, origem
calcularDistanciaPercorrida();
}
while(destino != (v1)) {
destino = tt[v2];
v2 = tt[v2];
Rota[cont] = Esquinas[v2];
71
cont++;
}
long tempo_fim = System.currentTimeMillis();
long tempo = tempo_fim - tempo_ini;
System.out.println("---> Rota Dijkstra --->");
for (int cont2 = 0; cont2 < Rota.length; cont2++) {
if (Rota[cont2] == -1) {
break;
}
System.out.print(Rota[cont2]+" ");
}
System.out.println("\nTempo de execução: "+tempo);
}
vertice = converterVertice2(viz);
S[cont2][vertice] = calc.getDistancia(Esquinas[cont2], viz);
}
}
Banco.rs1.close();
}
catch (Exception e){
System.out.println(e);
}
}