MESTRADO EM MÉTODOS COMPUTACIONAIS EM CIÊNCIAS …tavares/ensino/VISCI/Trabalhos/2003-2004... ·...

MESTRADO EM MÉTODOS COMPUTACIONAIS EM CIÊNCIAS E ENGENHARIA

Faculdade de Ciências da Universidade do Porto

Faculdade de Engenharia da Universidade do Porto

Visualização de Parâmetros de Entrada do Programa FastComp

Visualização Científica

2003/2004

Patrícia Carla Teixeira Gonçalves

ÍNDICE

1. Introdução ............................................................................................... 1

2. O FastComp ............................................................................................ 2

3. O VTK ...................................................................................................... 4

3.1. O modelo gráfico – classes utilizadas no programa ...................... 4

3.1.1. Janelas de renderização e renderers ................................. 4

3.1.2. Adereços, mapeadores e propriedades.............................. 5

3.1.3. Renderizar dados geométricos 3D ..................................... 5

3.1.4. Renderizar dados 2D.......................................................... 5

3.1.5. Interacção........................................................................... 6

4. O programa ............................................................................................. 7

4.1. Construção da junta ...................................................................... 7

4.2. Construção do parafuso ................................................................ 7

4.3. Construção do texto 2D................................................................. 7

4.4. Construção das setas e respectivo texto 3D ................................. 8

4.5. Resultados .................................................................................... 8

5. Conclusões ........................................................................................... 11

Apêndice – listagem do programa .......................................................... 12

Bibliografia consultada............................................................................ 22

Visualização de parâmetros de entrada do programa FastComp

1. Introdução

O propósito deste trabalho é construir um programa que permita a

visualização de alguns dados de entrada do FastComp. Este programa tem

vindo a ser desenvolvido no âmbito de uma tese de mestrado tendo até ao

momento resultado numa ferramenta computacional que permite

determinar as forças a que uma junta compósita aparafusada sujeita a

cargas multiaxiais aguenta até se dar a ruptura.

O nosso cérebro reage rapidamente a imagens, muito mais rapidamente

que a um conjunto de dados numéricos, por isso é que é tão importante

visualizar! Para o desenvolvimento dessa visualização construí um

programa em C++ baseado no sistema VTK (Visualization Toolkit, um

software orientado por objectos para gráficos 3D, visualização e

processamento de imagem.

Este trabalho apresenta, numa primeira parte, uma pequena apresentação

do FastComp. Seguidamente, é abordado o modelo gráfico do VTK. Na

terceira parte, é explicada a construção dos vários objectos do programa e

na última fase apresentam-se algumas conclusões. Em apêndice, encontra-

se o código do programa para a visualização de parâmetros de entrada do

FastComp.

1


2. O FastComp

O FastComp é uma ferramenta computacional para determinação das

forças que uma junta compósita aparafusada sujeita a cargas multiaxiais

aguenta até se dar a ruptura.

Os seus parâmetros de entrada são, entre outros, as constantes mecânicas

do material, as suas propriedades de ruptura, as tensões aplicadas e dados

geométricos:

Constantes mecânicas do material:

E1 – Módulo de Young na direcção das fibras (expresso em Nm-2);

E2 – Módulo de Young na direcção perpendicular à das fibras (Nm-2);

G12 – Módulo de Young de corte (Nm-2);

υ12 – Coeficiente de Poisson;

Propriedades de ruptura do material:

Xt – Tensão de ruptura à tracção na direcção das fibras (Nm-2);

Xc – Tensão de ruptura à compressão na direcção das fibras (Nm-2);

Yt – Tensão de ruptura à tracção na direcção perpendicular à das

fibras (Nm-2);

Yc – Tensão de ruptura à compressão na direcção perpendicular à

das fibras (Nm-2);

S – Tensão de ruptura ao corte (Nm-2).

Tensões aplicadas na junta e no parafuso:

Px – Tensão segundo o eixo dos xx (Nm-2);

Py – Tensão segundo o eixo dos yy (Nm-2);

P – Tensão no parafuso (Nm-2).

Dados geométricos:

d – diâmetro do furo do parafuso;

L – largura da junta.

2


O programa desenvolvido neste trabalho recaiu sobretudo na visualização

das tensões aplicadas na junta e no parafuso. Na figura 1 temos o caso

mais geral, uma junta sujeita a tensões no parafuso e ao longo do eixo dos

xx e dos yy.

Figura 1: Junta sujeita a tensões ao longo dos eixos e no parafuso.

3


3. O VTK

Programas computacionais podem gerar gigantescos volumes de dados de

difícil interpretação. Visualização é a transformação de dados ou

informação em imagens. Activa o nosso sentido mais primário – a visão –

bem como o poder de processamento da nossa mente. O cérebro humano

reage muito rapidamente a imagens visuais. “Uma imagem vale mil

palavras!”

O VTK (Visualization ToolKit) é um sistema de software de acesso livre,

orientado por objectos, para gráficos 3D, visualização e processamento de

imagem. É utilizado nas mais variadas aplicações: visualização médica,

exploração petrolífera, acústica, mecânica de fluidos, mapas

meteorológicos, etc., etc.

3.1. O MODELO GRÁFICO – CLASSES UTILIZADAS NO PROGRAMA

O VTK tem dois grandes subsistemas – o modelo gráfico e a pipeline de

visualização.

Os nomes das classes no modelo gráfico foram adaptados da indústria

cinematográfica. Luzes, câmaras, actores e adereços são classes com que

o utilizador cria uma cena.

3.1.1. Janelas de renderização e renderers

Para visualizar os dados é necessária a abertura prévia de uma janela no

ecrã do computador. A classe vtkRenderWindow representa o objecto onde

um ou mais renderers vão ser desenhados. Tal como a maioria dos

objectos gráficos, é activada automaticamente a subclasse dependente do

dispositivo correcta para a plataforma em uso. O vtkRenderWindow é uma

classe que contém objectos vtkRenderer. Podem ser dispostos múltiplos

4


renderers numa única janela de renderização de modo a criar visualizações

complexas.

3.1.2. Adereços, mapeadores e propriedades

Adereços (props) são os objectos adicionados ao renderer para criar a

cena. A classe vtkProp é uma classe abstracta para todos os adereços 2D

e 3D que contém informações sobre visibilidade, orientação, tamanho e

posição. Os adereços estão associados a um objecto mapeador (mapper) e

a um objecto propriedade. O mapeador refere-se a um objecto de dados de

introdução e sabe como o renderizar. O objecto propriedade contém

parâmetros de renderização como a cor e a aparência da superfície.

3.1.3. Renderizar dados geométricos 3D

Uma subclasse específica do vtkProp que pode ser utilizada para

representar dados geométricos a três dimensões numa cena é a vtkActor.

O objecto actor cria automaticamente um objecto vtkProperty, mas tem que

ser o utilizador a especificar a subclasse vtkMapper. Dependendo da

natureza da geometria referida pelo mapeador, tem que ser utilizada a

subclasse vtkDataSetMapper ou a vtkPolyDataMapper. Se os dados contêm

pontos, linhas ou polígonos representados pelo vtkPolyData então deve ser

usado o vtkPolyDataMapper. De outra forma, usa-se o vtkDataSetMapper.

Neste trabalho apenas foi necessária a utilização do vtkPolyDataMapper.

3.1.4. Renderizar dados 2D

Dados 2D incluem figuras geométricas, imagens e texto. O conceito de

actores, mapeadores e propriedades aplica-se tanto a dados 3D como 2D,

apesar de alguns dos parâmetros específicos serem diferentes. Para 2D, o

actor é conseguido com vtkActor2D que cria automaticamente um

vtkProperty2D.

5


3.1.5. Interacção

O objecto vtkRenderWindowInteractor permite que seja o rato, um joystick

ou uma trackball a controlar a posição e orientação da câmara e os

adereços da cena. O botão direito do rato controla a rotação, o do meio

segue o ponto focal e o botão direito controla o zoom.

6


4. O programa

O programa implementado constrói a junta (duas placa sobrepostas) e o

parafuso. Se os parâmetros de entrada permitirem, são também

construídas três setas em representação da orientação das tensões

aplicadas. Além disso, na janela de visualização são visíveis os dados

geométricos da junta sob a forma de dois objecto 2D.

4.1. Construção da junta

As placas da junta são objectos do tipo vtkCubeSource. Através desta

classe são definidos o comprimento, a largura e a altura da placa, que na

realidade é um cubo.

O mapper para cada uma das placas é feito através do vtkPolyDataMapper

e com o vtkActor, além de se criarem os actores a renderizar, é definida a

cor.

4.2. Construção do parafuso

O parafuso é constituído por três cilindros: um que define a cabeça do

parafuso, outro o corpo do parafuso e o último caracteriza a porca. Todos

eles são objectos do tipo vtkCylinderSource. Como objectos desta classe, a

forma específica de cada cilindro é obtida definindo raio, altura e centro

(que marca a posição na janela de cada cilindro). Tal como as placas da

junta, o mapper dos cilindros é obtido com o vtkPolyDataMapper e os

actores são criados com a classe vtkActor.

4.3. Construção do texto 2D

Para a criação do texto com os dados geométricos da junta tive que criar

dois objectos: um para o texto constante (d= e L=), outro para os

parâmetros de entrada. Para conseguir apenas dois objectos tive que

recorrer à concatenação de caracteres. Era minha intenção construir

7


apenas um objecto de texto concatenando todos os caracteres num só

string, infelizmente desta forma o programa não efectuava a renderização.

Os objectos foram construídos com base na classe vtkTextMapper e

criados os respectivos actores com vtkActor2D, definindo localização e cor.

4.4. Construção das setas e respectivo texto 3D

Se algum dos parâmetros de entrada relativos a Px, Py e P for nulo, a seta

que lhe corresponde não é desenhada. Se não for esse o caso, é criado um

objecto do tipo vtkArrowSource, mapeado por vtkPolyDataMapper. O actor é

do tipo 3D (vtkActor) e é definida a sua posição, orientação, tamanho e cor.

O texto 3D associado a cada uma das setas é obtido com vtkVectorText,

que também utiliza vtkPolyDataMapper e vtkActor.

4.5. Resultados

Nas figuras 2 e 3 estão representados os resultados finais, em duas

perspectivas diferentes, obtidos para Px=0.

8


Figura 2: Janela de renderização do programa para Px=0.

9


Figura 3: Janela de renderização do programa para Px=0. Perspectiva diferente da anterior.

10


5. Conclusões

Um outro parâmetro de entrada do FastComp é o ângulo que a tensão

aplicada faz com o eixo dos xx. Foram efectuadas várias tentativas para

que a orientação definida para os objectos vtkActor do tipo vtkArrowSource

fosse variável, ou seja, obtida dos parâmetros de entrada. Infelizmente

nenhuma teve êxito. No entanto, todos os resultados obtidos são os

inicialmente esperados, o que me deixa satisfeita com o VTK e comigo

própria.

11

APÊNDICE

LISTAGEM DO PROGRAMA


// // Visualização de parâmetros de entrada do programa FastComp // // Patrícia Gonçalves // // Mestrado de Métodos Computacionais em Ciências e Engenharia // Disciplina de Visualização Científica // // 29-07-2004 // //includes #include "vtkCubeSource.h" #include "vtkCylinderSource.h" #include "vtkArrowSource.h" #include "vtkVectorText.h" #include "vtkTextMapper.h" #include "vtkActor2D.h" #include "vtkPolyDataMapper.h" #include "vtkActor.h" #include "vtkProperty.h" #include "vtkProperty2D.h" #include "vtkRenderer.h" #include "vtkRenderWindow.h" #include "vtkRenderWindowInteractor.h" #include "iostream" #include "fstream" #include "string" #include "stdio.h" using namespace std; //função main int main() { ////////// Leitura do ficheiro com os parâmetros de entrada do ////////// programa FastComp char* palavra[57]; FILE* infx=fopen("C:\\Programas\\BJSFM_GIA\\in.txt", "r"); //criação de um buffer com os caracteres do ficheiro

13


char buffer[501]; int ch; for (int i=0; (i<500) && ((ch=fgetc(infx))!=EOF); i++) { buffer[i]=ch; } buffer[i]='\0'; //criação do vector que guarda as "palavras" do ficheiro char* p; int j=0; p=strtok(buffer, " \n"); while (p) { palavra[j]=p; p=strtok(NULL, " \n"); j++; } //visualização dos parâmetros de entrada do FastComp std::cout<<"Parametros do material:"<<endl<<endl; std::cout<<"E1: "<<palavra[17]<<"Nm-2\t"<<"E2: "<<palavra[18]<< "Nm-2"<<endl;; std::cout<<"G12: "<<palavra[19]<<"Nm-2\t"<<"miu12: "<< palavra[20]<<endl; std::cout<<"Xt: "<<palavra[21]<<"Nm-2\t"<<"Xc: "<<palavra[22]<< "Nm-2"<<endl; std::cout<<"Yt: "<<palavra[23]<<"Nm-2\t"<<"Yc: "<<palavra[24]<< "Nm-2"<<endl; std::cout<<"S: "<<palavra[25]<<"Nm-2"<<endl<<endl<<endl; std::cout<<"Tensoes:"<<endl<<endl; std::cout<<"na junta"<<endl; std::cout<<"Px= "<<palavra[42]<<"Nm-2\t"<<"Py= "<<palavra[43]<< "Nm-2"<<endl<<endl; std::cout<<"no parafuso"<<endl; std::cout<<"P= "<<palavra[46]<<"Nm-2"<<endl; ////////// Visualização dos parâmetros de entrada ////////// VTK //construção do renderer e definição de fundo cinzento vtkRenderer *ren1= vtkRenderer::New();

14


ren1->SetBackground(0.5, 0.5, 0.5); //dados do cubo1 - placa vtkCubeSource *cube1 = vtkCubeSource::New(); cube1->SetXLength(6); cube1->SetYLength(0.2); cube1->SetZLength(3); //mapper para o cubo1 vtkPolyDataMapper *cube1Mapper = vtkPolyDataMapper::New(); cube1Mapper->SetInput(cube1->GetOutput()); //actor cubo1 vtkActor *cube1Actor = vtkActor::New(); cube1Actor->SetMapper(cube1Mapper); (cube1Actor->GetProperty())->SetColor(1, 0, 0); //dados do cubo2 - placa vtkCubeSource *cube2 = vtkCubeSource::New(); cube2->SetXLength(6); cube2->SetYLength(0.2); cube2->SetZLength(3); cube2->SetCenter(3.5, 0.2, 0); //mapper para o cubo2 vtkPolyDataMapper *cube2Mapper = vtkPolyDataMapper::New(); cube2Mapper->SetInput(cube2->GetOutput()); //actor cubo2 vtkActor *cube2Actor = vtkActor::New(); cube2Actor->SetMapper(cube2Mapper); (cube2Actor->GetProperty())->SetColor(1, 0, 0); //dados do cilindro1 - cabeça do parafuso vtkCylinderSource *cylinder1 = vtkCylinderSource::New(); cylinder1->SetCenter(1.75, 0.5, 0); cylinder1->SetRadius(1); cylinder1->SetHeight(0.5); //mapper para o cilindro1 vtkPolyDataMapper *cylinder1Mapper = vtkPolyDataMapper::New(); cylinder1Mapper->SetInput(cylinder1->GetOutput());

15


//actor cilindro1 vtkActor *cylinder1Actor = vtkActor::New(); cylinder1Actor->SetMapper(cylinder1Mapper); (cylinder1Actor->GetProperty())->SetColor(0, 1, 0); //dados do cilindro2 - corpo do parafuso vtkCylinderSource *cylinder2 = vtkCylinderSource::New(); cylinder2->SetCenter(1.75, -0.2, 0); cylinder2->SetRadius(0.5); cylinder2->SetHeight(1.3); //mapper para o cilindro2 vtkPolyDataMapper *cylinder2Mapper = vtkPolyDataMapper::New(); cylinder2Mapper->SetInput(cylinder2->GetOutput()); //actor cilindro2 vtkActor *cylinder2Actor = vtkActor::New(); cylinder2Actor->SetMapper(cylinder2Mapper); (cylinder2Actor->GetProperty())->SetColor(0, 1, 0); //dados do cilindro3 - porca do parafuso vtkCylinderSource *cylinder3 = vtkCylinderSource::New(); cylinder3->SetCenter(1.75, -0.2, 0); cylinder3->SetRadius(0.7); cylinder3->SetHeight(0.5); //mapper para o cilindro3 vtkPolyDataMapper *cylinder3Mapper = vtkPolyDataMapper::New(); cylinder3Mapper->SetInput(cylinder3->GetOutput()); //actor cilindro3 vtkActor *cylinder3Actor = vtkActor::New(); cylinder3Actor->SetMapper(cylinder3Mapper); (cylinder3Actor->GetProperty())->SetColor(0, 1, 0); //mapper de texto - diâmetro e largura vtkTextMapper *textMapper1 = vtkTextMapper::New(); textMapper1->SetInput("d=\nL=\n"); //actor texto 2D vtkActor2D *textActor1 = vtkActor2D::New(); textActor1->SetMapper(textMapper1); textActor1->SetPosition(10,0);

16


(textActor1->GetProperty())->SetColor(0, 0, 1); //concatenação dos vários elementos do texto char a[ ]="mm\n"; strcat(palavra[49], a); strcat(palavra[49], palavra[48]); strcat(palavra[49], a); //mapper de texto - valores de diâmetro e largura vtkTextMapper *textMapper2 = vtkTextMapper::New(); textMapper2->SetInput(palavra[49]); //actor texto 2D vtkActor2D *textActor2 = vtkActor2D::New(); textActor2->SetMapper(textMapper2); textActor2->SetPosition(30,0); (textActor2->GetProperty())->SetColor(0, 0, 1); //envio dos actores para os renderers ren1->AddActor(cube1Actor); ren1->AddActor(cube2Actor); ren1->AddActor(cylinder1Actor); ren1->AddActor(cylinder2Actor); ren1->AddActor(cylinder3Actor); ren1->AddActor(textActor1); ren1->AddActor(textActor2); //apagar objectos da memória cube1->Delete(); cube2->Delete(); cylinder1->Delete(); cylinder2->Delete(); cylinder3->Delete(); cube1Mapper->Delete(); cube2Mapper->Delete(); cylinder1Mapper->Delete(); cylinder2Mapper->Delete(); cylinder3Mapper->Delete(); textMapper1->Delete(); textMapper2->Delete(); cube1Actor->Delete(); cube2Actor->Delete(); cylinder1Actor->Delete(); cylinder2Actor->Delete();

17


cylinder3Actor->Delete(); textActor1->Delete(); textActor2->Delete(); if (strcmp(palavra[42],"0")!=0) { //dados da seta1 - Px vtkArrowSource *arrow1 = vtkArrowSource::New(); //mapper da seta1 vtkPolyDataMapper *arrow1Mapper =

vtkPolyDataMapper::New(); arrow1Mapper->SetInput(arrow1->GetOutput()); //actor seta1 vtkActor *arrow1Actor = vtkActor::New(); arrow1Actor->SetMapper(arrow1Mapper); arrow1Actor->SetPosition(8, 0, 0); arrow1Actor->SetScale(3); (arrow1Actor->GetProperty())->SetColor(0, 0, 0); //envio do actor para o renderer ren1->AddActor(arrow1Actor); //dados do texto1 - Px vtkVectorText *text1 = vtkVectorText::New(); text1->SetText("Px"); //mapper para o texto1 vtkPolyDataMapper *text1Mapper = vtkPolyDataMapper::New(); text1Mapper->SetInput(text1->GetOutput()); //actor texto1 vtkActor *text1Actor = vtkActor::New(); text1Actor->SetMapper(text1Mapper); text1Actor->SetPosition(8, 0, 1); text1Actor->SetOrientation(-90, 0, 0); text1Actor->SetScale(0.5); (text1Actor->GetProperty())->SetColor(0, 0, 0); //envio do actor para o renderer ren1->AddActor(text1Actor); //apagar objectos da memória

18


arrow1->Delete(); text1->Delete(); arrow1Mapper->Delete(); text1Mapper->Delete(); arrow1Actor->Delete(); text1Actor->Delete(); } if (strcmp(palavra[43],"0")!=0) { //dados da seta2 - Py vtkArrowSource *arrow2 = vtkArrowSource::New(); //mapper da seta2 vtkPolyDataMapper *arrow2Mapper =

vtkPolyDataMapper::New(); arrow2Mapper->SetInput(arrow2->GetOutput()); //actor seta2 vtkActor *arrow2Actor = vtkActor::New(); arrow2Actor->SetMapper(arrow2Mapper); (arrow2Actor->GetProperty())->SetColor(0, 0, 0); arrow2Actor->SetPosition(1.75, 0, 3); arrow2Actor->SetOrientation(0, -90, 0); arrow2Actor->SetScale(3); //envio do actor para o renderer ren1->AddActor(arrow2Actor); //dados do texto2 - Py vtkVectorText *text2 = vtkVectorText::New(); text2->SetText("Py"); //mapper para o texto2 vtkPolyDataMapper *text2Mapper = vtkPolyDataMapper::New(); text2Mapper->SetInput(text2->GetOutput()); //actor texto2 vtkActor *text2Actor = vtkActor::New(); text2Actor->SetMapper(text2Mapper); text2Actor->SetPosition(0.25, 0, 3.5); text2Actor->SetOrientation(-90, 90, 90); text2Actor->SetScale(0.5);

19


(text2Actor->GetProperty())->SetColor(0, 0, 0); //envio do actor para o renderer ren1->AddActor(text2Actor); //apagar objectos da memória arrow2->Delete(); text2->Delete(); arrow2Mapper->Delete(); text2Mapper->Delete(); arrow2Actor->Delete(); text2Actor->Delete(); } if (strcmp(palavra[46],"0")!=0) { //dados da seta3 - P vtkArrowSource *arrow3 = vtkArrowSource::New(); //mapper da seta3 vtkPolyDataMapper *arrow3Mapper =

vtkPolyDataMapper::New(); arrow3Mapper->SetInput(arrow3->GetOutput()); //actor seta3 vtkActor *arrow3Actor = vtkActor::New(); arrow3Actor->SetMapper(arrow3Mapper); (arrow3Actor->GetProperty())->SetColor(0, 0, 0); arrow3Actor->SetPosition(1.75, 4.75, 0); arrow3Actor->SetOrientation(0, 0, -90); arrow3Actor->SetScale(3); //envio do actor para o renderer ren1->AddActor(arrow3Actor); //dados do texto3 - P vtkVectorText *text3 = vtkVectorText::New(); text3->SetText("P"); //mapper para o texto3 vtkPolyDataMapper *text3Mapper = vtkPolyDataMapper::New(); text3Mapper->SetInput(text3->GetOutput()); //actor texto3

20


vtkActor *text3Actor = vtkActor::New(); text3Actor->SetMapper(text3Mapper); text3Actor->SetPosition(2.25, 4.2, 0); text3Actor->SetScale(0.5); (text3Actor->GetProperty())->SetColor(0, 0, 0); //envio do actor para o renderer ren1->AddActor(text3Actor); //apagar objectos da memória arrow3->Delete(); text3->Delete(); arrow3Mapper->Delete(); text3Mapper->Delete(); arrow3Actor->Delete(); text3Actor->Delete(); } //construção da renderwindow e definição do tamanho vtkRenderWindow *renWin = vtkRenderWindow::New(); renWin->AddRenderer(ren1); renWin->SetSize(400, 400); //construção da interacção vtkRenderWindowInteractor * interactor =

vtkRenderWindowInteractor::New(); interactor->SetRenderWindow(renWin); //iniciar o render renWin->Render(); interactor->Start(); //apagar objectos restantes da memória ren1->Delete(); renWin->Delete(); interactor->Delete(); return 0; }

21


Bibliografia consultada

[PORTELA, 2004] Portela, P. (2004) FastComp: Strength prediction of

composite laminates containing stress concentrations using complex

variable theory. Tese do Mestrado em Engenharia Mecânica da

Faculdade de Engenharia da Universidade do Porto sob orientação do

Eng. Pedro Camanho. (a apresentar)

[TAVARES, 2004] Tavares, J., Barbosa, J. (2004) Apontamentos da disciplina

de Visualização Científica do Mestrado em Métodos Computacionais em

Ciências e Engenharia. Faculdade de Engenharia da Universidade do

Porto.

[SCHROEDER, 1998] Schroeder, J.,Martin, K., Lorensen, B. (1998) The

Visualization Toolkit. 2ª edição, Prentice Hall

[SCHROEDER, 2000] Schroeder, J., Avila. L., Hoffman, W. (Setembro/Outubro

2000) Visualizing with VTK: A Tutorial. Kitware

[VTK] VTK 4.2.1 Documentation

22

MESTRADO EM MÉTODOS COMPUTACIONAIS EM CIÊNCIAS …tavares/ensino/VISCI/Trabalhos/2003-2004... ·...

Documents

Transcript of MESTRADO EM MÉTODOS COMPUTACIONAIS EM CIÊNCIAS …tavares/ensino/VISCI/Trabalhos/2003-2004... ·...