Relatório Final de Progresso – F895

Programa Visualizador de Ondas Para Linux

Aluno: David D. Chinellato
Orientador: Engo. Pedro Raggio
 Relatório Final de Progresso – F895
Programa Visualizador de Ondas Para Linux
Aluno: David D. Chinellato
Orientador: Engo. Pedro Raggio

1 – Introdução

Para a disciplina F809 foi desenvolvido um programa visualizador de ondas para

plataforma Windows de bastante utilidade [1]. O programa, capaz de visualizar uma
sobreposição de duas ondas radiais cujos parâmetros eram dados pelo usuário, foi
construído em Freepascal, compilador livre de www.freepascal.org, e fazia uso de
instruções bastante primitivas graficamente.
Levantou-se então a possibilidade de utilizar uma plataforma totalmente de graça,
a plataforma linux. Inicialmente, tentou-se adaptar o código já existente (veja [1]) para o
mesmo compilador FreePascal para linux, sem afetar as rotinas gráficas; constatou-se
que esta abordagem não tinha sucesso devido às rotinas gráficas utilizadas pelo
programa.
Para solucionar o impasse foi criado o projeto de F895, que propôs que o
programa deveria ser reescrito em uma outra linguagem, C++, e deveria ser utilizado um
pacote gráfico muito mais sofisticado, o Simple DirectMedia Layer (de www.libsdl.org).
A linguagem C++, consideravelmente mais poderosa do que FreePascal e com
compiladores atuais, levaria a aumentos na performance previstos pelo projeto inicial.
Inicialmente, na segunda parte deste relatório, serão descritos os elementos usados
na concepção do novo programa. O programa segue exatamente o mesmo procedimento
do original, salvo melhorias nos métodos de cálculo numérico. Dado que o programa é
versão portada da plataforma Windows, sugere-se que o leitor interessado no
funcionamento do programa consulte a referência ao trabalho original, que contém
explicações bastante detalhadas do funcionamento do mesmo.
Depois disto, nas terceira e quarta partes do relatório será explicada a
implementação em C++ do programa e a operação do programa por um usuário qualquer,
respectivamente. A compreensão do funcionamento não é fundamental à operação do
programa. E, finalmente, a quarta parte deste relatório traz uma reprodução exata do que
foi compilado para a apresentação no dia 23/11/04.
2 – Elementos utilizados para a programação

O primeiro elemento escolhido foi o sistema operacional.

Optou-se por SuSE Linux 9.1 Professional (www.suse.com), pois
este sistema operacional é bastante robusto e moderno e tem
pacotes de desenvolvimentos de software integrados ao sistema
operacional. A instalação do SuSE 9.1 Pro foi realizada em um
computador do aluno, por motivo de praticidade.

Em seguida, foi determinado que trabalhar-se-ia com o

pacote de desenvolvimento de software integrado KDevelop
3.0, contando inclusive com suporte a C++, Pascal, Fortran, e
muitos outros. O programa KDevelop é instalado com o sistema
operacional e se encontra automaticamente utilizável e capaz de
compilar C++, mas não há um guia de referência ou um
manual de C++ ou qualquer tipo de auxílio. Para isto,
consultou-se as referências [2], [3] e [4].

O terceiro elemento escolhido foi o pacote gráfico.

Depois de apropriada pesquisa em relação às opções, optou-se
por utilizar a biblioteca do Simple DirectMedia Layer, um
pacote gráfico com suporte a várias plataformas que pode ser
encontrado, juntamente com guias e tutoriais, em
www.libsdl.org. As rotinas e bibliotecas de execução de SDL
são de tamanha utilidade que até mesmo alguns jogos
modernos, como Civilization: Call to Power, foram escritos
com SDL.

Estas ferramentas são suficientes para a criação do software em questão.

Veremos agora os detalhes do programa criado com estas ferramentas.
3 – Implementação

Construiu-se um programa inteiramente novo para fazer exatamente o que o

programa original realizava, mas de maneira melhor e mais rápida. O programa original
tinha dois módulos de renderização: o primeiro, rápido, que fazia uso de triângulos para
representar a superfície na qual as ondas se encontravam, e o segundo,
extraordinariamente lento, mas de qualidade inigualável, que fazia uma renderização por-
pixel da imagem.
Desde o início, foi pensado que o programa, quando reescrito e recompilado para
C++, seria mais veloz. Foi então melhorado o algoritmo de renderização a um ponto no
qual a renderização por pixel tornava a por triângulos obsoleta, por ser de maior
representatividade e demorar um tempo muito mais aceitável do que originalmente. Desta
forma, o programa, na sua forma atual para SuSE Linux, não usa triângulos, mas apenas
pixels. Trata-se de escolha que fez com que o programa ficasse muito mais conciso e
menor – o original era constituído de cerca de 1250 linhas, enquanto o programa atual
possui pouco mais de 500 linhas.
Para as melhorias no cálculo numérico associado à renderização do pixel, foram
implementadas duas medidas bastante relevantes. A primeira delas foi amostrar a
superfície constituída da sobreposição das duas ondas pela simples soma das suas
amplitudes (veja referência [5] para reprodução integral do código fonte) enquanto a
amostragem de uma profundidade para um determinado pixel da tela ainda tiver valor de
z superior à soma das duas amplitudes; assim, pede-se ao programa basicamente que
encontre automaticamente o corte entre a direção de determinado pixel e um plano com z
igual à soma das duas amplitudes.
A segunda medida relevante à otimização do programa é referente a como
encontrar a intersecção da reta designada a uma direção correspondente a um pixel.
Basicamente, o que foi feito de novo é a implementação eficiente de um algoritmo de
bissecção de cálculo numérico básico. Quando a reta encontra a superfície, o programa
voltará metade do incremento que fez com que o ponto da reta estivesse abaixo da
superfície; se ainda continuar dentro, volta um quarto, e assim por diante. O método foi
implementado com 6 passos, o que faz o programa encontrar um ponto de encontro um
ponto de intersecção muito mais adequado do que anteriormente e faz com que o
programa seja executado basicamente com 64 vezes a precisão (ou velocidade) do
método originalmente implantado para o projeto original de F809.
Estas duas melhorias foram as únicas diferenças na implementação em
FreePascal e em C++. O código em si foi reduzido ao mínimo operacional e reescrito de
forma mais elegante de qualquer forma, mas o algoritmo continua sendo essencialmente
o mesmo.

4 – Operação do Programa

O programa efetua basicamente a mesma operação que antes. Trata-se da

representação completa de uma sobreposição de duas ondas da forma 4.1.

2π
r

ϕ (x, y ) = Ae τ sin (x − x0 )2 + ( y − y 0 )2 (4.1)

−
r −φ , r=
λ

Os parâmetros de 4.1 são todos modificáveis, de modo que as duas funções

podem ser livremente manipuladas pelo usuário quando da execução do programa. Além
disso, o programa representa as funções como se vistas por um observador em uma
posição, que daqui em diante será chamada de câmera, que também é alterável pelo
usuário em tempo de execução. Para um realismo adicional na representação, o usuário
pode também especificar o ponto no qual se encontra a fonte de luz, sendo esta a
responsável pelo sombreamento das ondas. Este sombreamento é crucial para a
compreensão apropriada do sistema visualizado. O programa admite 6 parâmetros
modificáveis para cada uma das duas funções (amplitude, comprimento de onda,
atenuação, fase, coordenadas de centro X e Y), 3 parâmetros para posição da câmera e 3
parâmetros para posição da fonte de luz.
De qualquer forma, o programa inicializará mostrando um menu de opções
idêntico ao reproduzido em 4.2. As opções são feitas para serem auto-explicativas; pode-
se renderizar a figura de acordo com os parâmetros de desenho atuais seguindo a opção
(1); a opção (2) abre um novo menu que será discutido posteriormente. Além destas,
existe a manipulação de parâmetros: (3) salva os parâmetros atuais em um arquivo-
padrão do programa (“params.txt”); (4) reverte para os últimos parâmetros salvados
(lidos do mesmo arquivo, “params.txt”) e (5) reinicializa os parâmetros para um padrão
codificado no programa que é razoável para um começo.

========================================================
=Programa visualizador de ondas bidimensionais =
========================================================
versão 1.02, trabalhando SDL a 640x480

1) Renderizar figura
2) Alterar parâmetros de desenho
3) Salvar parâmetros (4.2)
4) Reverter a parâmetros salvados
5) Reinicializar parâmetros para padrão

9) Encerrar programa

Sua opção:

Quando o usuário renderizar uma figura usando a opção (1), o programa salvará
uma cópia da imagem, quando concluída, em um arquivo bmp de nome “lastpic”.
Este recurso pode ser especialmente útil se o usuário estiver interessado em utilizar a
imagem para alguma finalidade específica.
A opção (2) abre um novo menu ao usuário, oferecendo assim os 18 parâmetros
modificáveis do programa. Este menu pode ser visto em (4.3).

======================================
=Alteração de parâmetros para desenho=
======================================

============================================================
= 1, 2, 3 = Posição X (1), Y (2), Z (3) da câmera =
= 4, 5, 6 = Posição X (4), Y (5), Z (6) da fonte de luz =
============================================================
= 7, 8 = Posição X (7), Y (8) do centro da onda 1 =
= 9 = Amplitude da onda 1 =
= 10 = Comprimento de onda da onda 1 =
= 11 = Atenuação (meia-altura) da onda 1 =
(4.3)
= 12 = Fase da onda 1 =
============================================================
= 13, 14 = Posição X (13), Y (14) do centro da onda 2 =
= 15 = Amplitude da onda 2 =
= 16 = Comprimento de onda da onda 2 =
= 17 = Atenuação (meia-altura) da onda 2 =
= 18 = Fase da onda 2 =
============================================================

Entre com a sua escolha:

 Os parâmetros de (4.3) são bastante intuitivos. A correspondência dos parâmetros
de onda vistos em (4.3) é imediata com as constantes observadas em (4.1). Quando
pedido para alterar um parâmetro, o programa informará o valor atual daquela variável
para comparação e permitirá que o usuário entre com um novo valor. Se o usuário entrar
com um número que não consta na lista (4.3), ele será retornado ao menu principal, (4.2).
Se, neste menu principal, o usuário entrar com um número igual ou maior que 9, o
programa encerrará sua execução. Qualquer outro número sem operação associada
retornará o usuário ao menu principal, sempre.
Dois outros parâmetros podem ser modificados, mas não estão oficialmente
incluídos na lista devido a alguns problemas que não puderam ser explicados até o
presente momento. São estes: tangente do ângulo de visão da câmera (como na
implementação original; entre a opção (19) no menu (4.3) e o programa alterará, sem
garantias, a variável em questão; e a resolução de renderização, de maneira inteiramente
análoga ao programa anterior. Para alterar a resolução de renderização para um valor não-
padrão, entre com o número (20) no menu (4.3). A operação do programa não é
garantida para quaisquer valores destes dois últimos parâmetros.
O código fonte se encontra, em sua totalidade, na referência [5].

5 – Referências e Bibliografia

! " # $% &'
# ( ) ! * + ' " * ' " ,-.
/ 0 1 2 3 !" * ' " ,,
4 # 5 ' 6

7 6 + " " " 1 ' $% 6

" 889 99 " " ' 8 8 8 :;87 <

" 889 99 = > &8 8 ? 9 ? ? " " :;87 <
" 88' & 9 ' 8 8' #8 # " :;87 <
" 889 99 6 18 1 8 9 & 1 8! ( ? @ ; :! ( <
" 88 8 > " " :! ( <