mestrado em mÉtodos computacionais em ciÊncias …tavares/ensino/visci/trabalhos/2003-2004... ·...
TRANSCRIPT
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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
Figura 2: Janela de renderização do programa para Px=0.
9
Visualização de parâmetros de entrada do programa FastComp
Figura 3: Janela de renderização do programa para Px=0. Perspectiva diferente da anterior.
10
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
// // 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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
//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
Visualização de parâmetros de entrada do programa FastComp
(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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
(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
Visualização de parâmetros de entrada do programa FastComp
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
Visualização de parâmetros de entrada do programa FastComp
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