1. Introdução Triangulação de Delaunay Algoritmo quadrático Métodos Utilizados Resultados...

Transcrição

1 1 Conteúdos 1. Introdução The Visualization Toolkit A Biblioteca VTK Conjuntos de Dados Organização do Volume de Dados A Estrutura de Classes do VTK Triangulação de Delaunay Algoritmo quadrático Métodos Utilizados Resultados Conclusão Apêndice... 23

2 2 1. Introdução O objecto de trabalho insere-se na área de visualização científica e consiste na exploração e aplicação do software VTK. Em particular serão focados métodos de triangulação e de manipulação de dados. Será usada a triangulação 2D de Delaunay a partir das ferramentas do vtk de forma a construir uma topologia a partir de pontos não estruturados de uma imagem. Para tal é feita a importação de uma imagem BMP e a obtenção das coordenadas dos pontos que a definem. A partir desses pontos criada uma estrutura de pontos sobre a qual será feita a triangulação. Serão ainda exploradas técnicas de visualização como sendo a inserção de texto e a renderização.

3 3 2. The Visualization Toolkit 2.1. A Biblioteca VTK O Visualization ToolKit é um sistema de software de código aberto para computação gráfica 3D, processamento de imagens, e visualização, usado por milhares de pesquisadores e investigadores em todo o mundo. Consiste numa biblioteca de classes em C++ e várias camadas de interfaces interpretadas, incluindo Tcl/Tk, Java, e Python, e suporta uma ampla variedade de algoritmos de visualização para diferentes tipos de dados. Também são implementadas técnicas de modelagem avançadas como modelagem implícita, redução de polígonos, suavização de malhas e triangulação de Delaunay. O projecto e a implementação da biblioteca foram fortemente influenciados pelos princípios de orientação a objectos, e o software foi instalado e testado em quase todas as plataformas baseadas em Unix e Windows. O modelo de programação do VTK adopta o paradigma de fluxo de dados. Nesse paradigma, módulos são conectados para formar uma rede que descreve um canal (pipeline) de processamento de dados. Os módulos executam operações algorítmicas sobre os dados enquanto eles fluem pelo pipeline. No modelo VTK há dois tipos básicos de objectos: objectos de processos e objectos de dados. Objectos de processo são os módulos do pipeline, e objectos de dados representam os dados nos vários estágios no pipeline. Essencialmente, o investigador está ciente apenas dos objectos de processos e os objectos de dados vivem entre os objectos de processo. Figura 2.1: Modelo VTK. Objectos de processos A, B e C são objectos fonte, filtro e mapeador, respectivamente. Objectos de processo são de três tipos: fontes, filtros e mapeadores (ver figura 2.1). Objectos fontes são encontrados no início do pipeline, e geram uma ou mais saídas de dados. Um objecto fonte pode ser um leitor para um tipo de arquivo particular ou pode gerar seu próprio dado, como o objecto vtkspheresource, que cria uma representação

4 4 (objecto de dados) de uma esfera poligonal. A saída desse objecto fonte pode então ser conectada à entrada de outro objecto de processo. O acto de conectar a entrada de um objecto de processo à saída de outro objecto de processo define como o pipeline está construído. Por exemplo, para conectar a saída do filtro A à entrada do filtro B, é usada a seguinte construção: B->SetInput( A->GetOutput( ) ); Como as conexões podem ser múltiplas (uma saída pode ser entrada de vários objectos), as conexões podem, de facto, tornarem-se numa rede (network) de visualização, em vez de um pipeline simples. Cada objecto de processo gera apenas uma saída. O pipeline ou rede termina com mapeadores. Um mapeador mapeia a sua entrada para a tela (render). Nesse estágio do pipeline, a entrada para o mapeador é a saída de algum filtro que gera dados geométricos (vtkpolydata). Os dados geométricos são objectos de dados como qualquer outro que representam malhas planares irregulares. De facto, há filtros que trabalham com dados geométricos, como algoritmos de triangulação (vtktrianglefilter). O mapeador é associado a um objecto chamado vtkactor, que representa um objecto geométrico e os seus atributos na cena. Informações num vtkactor incluem os atributos de aparência do objecto (vtkproperty) e sua localização no espaço. Como resultado, o investigador instancia pelo menos um vtkactor para cada mapeador no pipeline do VTK, e um mapeador para cada objecto geométrico que deverá ser renderizado. O investigador ajusta cada atributo de cada vtkactor e adiciona cada vtkactor a uma janela de renderização, usada por uma instância da classe de vtkrenderwindow. A janela resultante exibe todos os actores a ela associados. Uma das principais vantagens do VTK são os seus recursos para interacção com os gráficos 3D gerados. Tais recursos possibilitam que o usuário navegue através dessas imagens, e, consequentemente, através dos dados. A classe do VTK chamada vtkrenderwindowinteractor é a responsável por transformar eventos do rato e teclado em modificações aos actores e câmaras que compõem a visualização. Operações como rotação, translação, escala e trackball estão implementadas, entre outras. 2.2 Conjuntos de Dados Os dados em visualização científica podem ser definidos sobre domínios 2D, 3D e, genericamente, multidimensionais. Geralmente, um conjunto de dados possui uma certa

5 5 organização como uma malha (ou grade) de células. As células também são elementos de volumes unitários, porém os dados estão posicionados nos seus vértices, enquanto que, nos voxels, os dados estão armazenados em seu interior. Os valores podem ser obtidos no interior de células através de interpolação. (figura 2.2). Figura 2.2: (a) Malha regular volumétrica, (b) malha de voxels, (c) malha de células. Os dados também podem constituir um conjunto de pontos esparsos ou malhas geométricas de outra natureza. Além disso, as informações associadas a cada ponto da malha podem ser um ou mais valores escalares, vectoriais ou tensoriais. Um conjunto de dados consiste de duas partes: uma estrutura de organização e atributos de dados complementares associados à estrutura. A estrutura tem duas partes: uma topologia e uma geometria. A topologia é um conjunto de propriedades invariantes sob certas transformações geométricas (como por exemplo, rotação e translação). A geometria é a instanciação da topologia, ou seja, a especificação da posição no espaço 3D. Por exemplo, quando se declara que um polígono é um ``triângulo'', está-se a especificar a topologia. E quando se fornece as coordenadas dos pontos, está-se a especificar a geometria. Os atributos, por sua vez, são informações complementares que podem estar associadas tanto à geometria como à topologia. 2.3 Organização do Volume de Dados O volume de dados representa o trecho do espaço 3D onde se localiza o objecto, dado ou cena a ser renderizada. Uma malha faz referência à organização do volume de dados. Existem diferentes tipos de malhas: Em uma malha cartesiana todos os elementos são quadrados (no caso 2D) ou cubos idênticos (no caso 3D), alinhados aos eixos principais. É a forma ideal de estrutura, pois permite o acesso mais rápido aos dados. Uma malha

6 6 regular tem todos os seus elementos idênticos e alinhados aos eixos, mas esses elementos são rectângulos ou paralelepípedos de dimensões constantes. Elementos de uma malha rectilínea são quadriláteros ou hexaedros alinhados aos eixos, mas não necessariamente idênticos. Elementos de uma malha estruturada são quadriláteros ou hexaedros não alinhados aos eixos principais, como os que aparecem em grades esféricas ou curvilíneas. Uma malha estruturada em blocos é um conjunto de malhas estruturadas agrupadas. Uma malha não-estruturada contém polígonos ou poliedros sem qualquer padrão explícito de conectividade. No caso 3D, as células podem ser tetraedros, hexaedros, pirâmides, etc. Uma malha híbrida é uma combinação de quaisquer dos tipos anteriores (figura 2.3). Figura 2.3: Tipos de malhas: (a) Cartesiana, (b) Regular, (c) Rectilínea, (d) Estruturada, (e) Não-estruturada. 2.4 A Estrutura de Classes do VTK Abaixo seguem algumas das classes presentes no VTK que representam os conjuntos de dados suportados pela biblioteca e seus mapeadores. Todos os objectos criados no VTK, com poucas excepções, são especializações (subclasses) da classe abstracta vtkobject ou de um de seus filhos. Essa classe base fornece métodos de controlo para cada objecto criado pela biblioteca, incluindo triagem do tempo de modificações, depuração e impressão. Os conjuntos de dados de visualização suportados pelo VTK são mostrados na figura 2.4. Para a representação desses conjuntos de dados foi criada a classe genérica vtkdataobject. Objectos do tipo conjunto de dados (datasets) implementam os tipos de dados fundamentais tipicamente usados em visualização. Esses objectos de dados são entrada e saída de fontes, filtros e mapeadores. A classe abstracta vtkdataset especifica uma interface que todas as classes derivadas precisam fornecer. Ela também provê métodos que fornecem informações sobre os dados, tais como o centro do objecto, caixa de bordo (limites espaciais do domínio de dados) e largura representativa (comprimento da diagonal da caixa de borda). Um conjunto de dados no VTK consiste de uma estrutura definida por

7 7 geometria e topologia, e de atributos de dados associados, sendo composto por um ou mais pontos e células. A figura 2.5 mostra o diagrama de classes do vtkdataset e suas subclasses. O tipo de um conjunto de dados é determinado pela sua estrutura de organização, e especifica o relacionamento que as células e pontos têm entre si. Figura 2.4: Tipos de conjuntos de dados (datasets) do VTK. A ``Malha Não Estruturada'' consiste de todos os tipos de célula. Para trabalhar com malhas do tipo cartesiana, o VTK possui uma classe chamada vtkstructuredpoints. A vtkstructuredpoints representa uma estrutura geométrica que é uma matriz de pontos topologicamente e geometricamente regular. Essa estrutura é utilizada para o armazenamento de figuras bidimensionais, como texturas, e dados

8 8 volumétricos para a representação em DVR ou reconstrução. A classe vtkrectilineargrid representa uma malha rectilínea. A classe abstracta vtkpointset especifica a interface para conjuntos de dados que usam explicitamente matrizes de pontos para representar geometria. Por exemplo, vtkpolydata e vtkunstructuredgrid requerem matrizes de pontos para especificar as posições dos pontos, enquanto vtkstructuredpoints gera posições de pontos implicitamente. A vtkstructuredgrid representa uma malha estruturada. A classe vtkunstrucuredgrid consiste de uma combinação arbitrária de células 2D e 3D, além de pontos. Geometria e Topologias são explicitamente definidas.

9 9 Figura 2.5: Diagrama de objectos dos tipos de dados do VTK herdeiros de vtkdataset. A maioria das fontes do VTK gera objectos no formato ``dados poligonais'', ou PolyData, que é um tipo de conjunto de dados que pode ser facilmente renderizado para bibliotecas gráficas. A classe vtkpolydata representa esse tipo de estrutura geométrica, consistindo de vértices, linhas, polígonos e faixa de triângulos. Ela é a estrutura utilizada durante o processo de renderização dos conjuntos de dados geométricos do VTK, que ocorre através da classe vtkpolydatamapper. A classe vtkpolydatamapper é a classe que mapeia dados poligonais (PolyData) para primitivas gráficas renderizáveis. Ela é uma super classe de mapeadores poligonais para dispositivos específicos, como a biblioteca OpenGL. O usuário não precisa seleccionar qual dispositivo o VTK usará. Ele simplesmente aloja um mapeador de dados poligonais e o VTK escolhe o dispositivo adequado para a renderização. Para os outros tipos de dados, é utilizada a classe vtkdatasetmapper, que é um mapeador de conjuntos de dados (vtkdataset e todas classes derivadas) para primitivas gráficas. A classe vtkdatasetmapper não possui subclasses específicas. O processo de renderização desse mapeador converte o conjunto de dados (DataSet) para dados poligonais (PolyData) através de um filtro e renderiza utilizando o vtkpolydatamapper.

10 10 3. Triangulação de Delaunay A triangulação de um conjunto de pontos consiste em encontrar segmentos de recta que conectam estes pontos de tal modo que nenhum desses segmentos cruze com nenhum outro e que cada ponto seja vértice de pelo menos um triângulo formado por esses segmentos. Esses segmentos particionam o conjunto de pontos em triângulos, daí o nome Triangulação. O grafo dual de um Diagrama de Voronoi constitui uma triangulação cujos pontos são os pontos construtores do diagrama de Voronoi. A esta triangulação particular dá-se o nome de Triangulação de Delaunay. De fato existe um algoritmo que, dado um Diagrama de Voronoi, obtém a Triangulação de Delaunay em tempo linear. Outro algoritmo faz o serviço inverso, também em tempo O(n). Porém, existem algoritmos que produzem a Triangulação de Delaunay directamente do conjunto de pontos. Um triângulo da Triangulação de Delaunay tem a seguinte propriedade: determina um círculo cujo interior não contém nenhum outro ponto do conjunto de pontos a não ser os três pontos que determinam o triângulo. 3.1 Algoritmo quadrático Um algoritmo quadrático que produz a Triangulação de Delaunay pode ser descrito da seguinte forma: primeiro procura-se uma aresta qualquer do fecho convexo. Essa aresta com certeza estará em qualquer triangulação pois o fecho convexo está sempre contido numa triangulação. A ideia básica deste algoritmo é usar as arestas já determinadas para encontrar as demais. Toda aresta da triangulação pertence a um ou dois triângulos. Uma aresta só incide num triângulo se for uma aresta do fecho convexo. A partir de uma aresta adjacente a uma face já conhecida (um triângulo ou a face externa) pode-se determinar o outro triângulo que compartilha esta aresta da seguinte maneira: encontrar o ponto p do lado apropriado do segmento para o qual o círculo determinado pelo triângulo contendo os vértices do segmento e o ponto p não possui nenhum outro ponto do conjunto interno a ele. Esse triângulo é uma componente da Triangulação de Delaunay.

11 11 O algoritmo é fácil de ser implementado pois não requer a utilização de estruturas de dados complicadas. Basta uma fila de arestas não-inspecionadas e uma matriz de adjacência.

12 12 4. Métodos Utilizados Nesta secção estão descritas as classes do vtk utilizadas // Leitura do ficheiro BMP vtkbmpreader *imagein = vtkbmpreader::new(); imagein->setfilename("c:\\windows\\ambiente de trabalho\\d\\ice.bmp"); // Criação do actor para imagem vtkimageactor *imgactor = vtkimageactor::new(); imgactor->setinput(imagein->getoutput()); // Extrai o número de componentes escalares dos pontos da imagem vtkimageconstantpad *pad = vtkimageconstantpad::new(); pad->setinput(imagein->getoutput()); pad->setoutputnumberofscalarcomponents(3); pad->setconstant(0); // Criar um conjunto de pontos estruturados a partir da imagem // e do número de componentes. vtkimagetostructuredpoints *i2sp1 = vtkimagetostructuredpoints:: New(); i2sp1->setinput(imagein->getoutput()); i2sp1->setvectorinput(pad->getoutput()); vtkstructuredpoints *ppoints = i2sp1->getoutput(); ppoints->update(); int n = ppoints->getnumberofpoints();

13 13 vtkdataarray *ptscalars; ptscalars = (ppoints->getpointdata())->getscalars(); float rgb[3]; float x[3]; printf("\n n=%d", n); printf("\n size=%d", ptscalars->getsize()); vtkmath *math = vtkmath::new(); vtkpoints *points = vtkpoints::new(); vtkcellarray *polys = vtkcellarray::new(); register int i; // Criação de uma polydata com os pontos da imagem for (i = 0; i < n; i++) { } ppoints->getpoint(i, x); ((ppoints->getpointdata())->getscalars())->gettuple(i, rgb); points->insertpoint(i, x[0], x[1], (rgb[0]*20+rgb[1]*59+rgb[2]*11)/100); polys->insertnextcell(1); polys->insertcellpoint(i); // Introdução da Polydata vtkpolydata *profile = vtkpolydata::new(); profile->setpoints(points); profile->setverts(polys); // Criação do actor de entrada relativo ao mapa de pontos

14 14 vtkpolydatamapper *mappoints = vtkpolydatamapper::new(); mappoints->setinput(profile); vtkactor *actorpoints = vtkactor::new(); actorpoints->setmapper(mappoints); (actorpoints->getproperty())->setcolor(0, 0, 1); // Triangulação 2D Delaunay a partir dos pontos. vtkdelaunay2d *del = vtkdelaunay2d::new(); del->setinput(profile); del->settolerance(0.1); // Criação o actor de saída vtkdatasetmapper *map = vtkdatasetmapper::new(); map->setinput(del->getoutput()); // map->setinput(ppoints); vtkactor *triangulation2d = vtkactor::new(); triangulation2d->setmapper(map); (triangulation2d->getproperty())->setcolor(1, 0, 0); // Criação de dados de texto vtkvectortext *text1 = vtkvectortext::new(); text1->settext("imagem BMP"); vtkvectortext *text2 = vtkvectortext::new(); text2->settext("pontos"); vtkvectortext *text3 = vtkvectortext::new();

15 15 text3->settext("triangulacao"); // Mapeação dos vectores de texto vtkpolydatamapper *textmapper1 = vtkpolydatamapper::new(); textmapper1->setinput(text1->getoutput()); vtkpolydatamapper *textmapper2 = vtkpolydatamapper::new(); textmapper2->setinput(text2->getoutput()); vtkpolydatamapper *textmapper3 = vtkpolydatamapper::new(); textmapper3->setinput(text3->getoutput()); // Criação do actor de texto vtkactor *textactor1 = vtkactor::new(); textactor1->setmapper(textmapper1); (textactor1->getproperty())->setcolor(0, 0, 0); vtkactor *textactor2 = vtkactor::new(); textactor2->setmapper(textmapper2); (textactor2->getproperty())->setcolor(0, 0, 0); vtkactor *textactor3 = vtkactor::new(); textactor3->setmapper(textmapper3); (textactor3->getproperty())->setcolor(0, 0, 0); // Construção de renderers vtkrenderer *ren1= vtkrenderer::new();; ren1->addactor(textactor1); ren1->setbackground(1, 1, 1); ren1->setviewport(0, 0.45, 0.33, 1);

16 16 vtkrenderer *ren4= vtkrenderer::new();; ren4->addactor(imgactor); ren4->setbackground(1, 1, 1); ren4->setviewport(0, 0, 0.33, 0.70); vtkrenderer *ren2= vtkrenderer::new(); ren2->addactor(textactor2); ren2->setbackground(1, 1, 1); ren2->setviewport(0.33, 0.60, 0.66, 1); vtkrenderer *ren5= vtkrenderer::new(); ren5->addactor(actorpoints); ren5->setbackground(1, 1, 1); ren5->setviewport(0.33, 0, 0.66, 0.70); vtkrenderer *ren3= vtkrenderer::new(); ren3->addactor(textactor3); ren3->setbackground(1, 1, 1); ren3->setviewport(0.66, 0.45, 1, 1); vtkrenderer *ren6= vtkrenderer::new(); ren6->addactor(triangulation2d); ren6->setbackground(1, 1, 1); ren6->setviewport(0.66, 0, 1, 0.70); // renderwindow vtkrenderwindow *renwin1 = vtkrenderwindow::new(); renwin1->addrenderer(ren1); renwin1->addrenderer(ren2); renwin1->addrenderer(ren3); renwin1->addrenderer(ren4);

17 17 renwin1->addrenderer(ren5); renwin1->addrenderer(ren6); renwin1->setsize(1024, 500); // Janela de interação vtkrenderwindowinteractor * interactor1 = vtkrenderwindowinteractor::new(); interactor1->setrenderwindow(renwin1); renwin1->render(); interactor1->start(); // apagar os objectos construídos math->delete(); points->delete(); polys->delete(); profile->delete(); del->delete(); map->delete(); ren1->delete(); ren2->delete(); ren3->delete(); ren4->delete(); ren5->delete(); ren6->delete(); renwin1->delete(); interactor1->delete();

18 18 5. Resultados A compilação do código elaborado foi feita através do Microsoft Studio C++. Os resultados que se seguem ilustram não só o método de triangulação de Delaunay descrito anteriormente como também as potencialidades do vtk como programa de visualização. As figuras seguintes serviram de exemplo para utilizar como teste na obtenção dos pontos estruturados. Figura 5.1. Imagens BMP utilizadas na aplicação: à esquerda a figura ice1.bmp e à direita a figura ice2.bmp A compilação do projecto resulta na renderização de uma janela com 6 actores: 3 actores de texto com o título dos outros 3 actores correspondentes às mapeações obtidas. A utilização de duas imagens exemplo provém da necessidade de explicar a tolerância da triangulação de Delaunay ao número de pontos obtidos. A figura seguinte é o Output da renderização para a primeira imagem. O primeiro mapper é simplesmente a visualização da imagem BMP com o respectivo título. No segundo é a apresentada a estrutura de pontos obtida e por o resultado da triangulação. O número de pontos obtidos e utilizados na triangulação foi de A figura 5.3. é resultado da rotação dos actores de forma a visualizar em pormenor o resultado obtido.

19 19 Figura 5.2 Visualização da Triangulação de Delaunay na imagem ice1.bmp Figura 5.3 Visualização da Triangulação de Delaunay na imagem ice1.bmp, depois de aplicadas rotações sobre os actores. As figura 5.4 e 5.5 ilustram o mesmo processo mas aplicado à imagem ice2.bmp. Neste caso o número de pontos foi de

20 20 Figura 5.4 Visualização da Triangulação de Delaunay na imagem ice2.bmp Figura 5.5 Visualização da Triangulação de Delaunay na imagem ice2.bmp, depois de aplicadas rotações sobre os actores. Por comparação verifica-se que a resolução do segundo exemplo é muito maior do que a do primeiro exemplo. Isto deve-se ao facto de que a tolerância da triangulação usada no primeiro exemplo foi de 0.1 e neste caso de No primeiro caso o número de pontos era demasiado elevado para aplicar uma tolerância de 0.01 pois o esforço computacional era inapropriado. Mas para perceber melhor a diferença de resultados na diminuição de tolerância a figura 5.6 é o resultado da aplicação de uma tolerância de 0.1 na imagem ice2.bmp.

21 21 Figura 5.5 Visualização da Triangulação na imagem ice2.bmp com tolerância 0.1. Depois de feita a triangulação não é possível distinguir os dois icebergs presentes na imagem, visto que o número de pontos utilizado foi muito pequeno.

22 22 6- Conclusão A aplicação da triangulação 2D de Delaunay permite definir uma estrutura topológica a partir de pontos de uma imagem. A determinação das coordenadas dos pontos da imagem depende directamente da composição RGB da imagem. Isto é, quanto maior for a diferença cromática da imagem a maior será a diferença de valores obtidos na terceira coordenada dos pontos. O número de triângulos é estabelecido pelo número de pontos e pela tolerância da triangulação. Quanto menor for a tolerância maior o número de triângulos. Existe assim um compromisso entre a tolerância e o esforço computacional. É necessário verificar o número de pontos de forma a definir uma tolerância adequada à capacidade de processamento da máquina.

23 23 Apêndice /*################################################################ // Trabalho realizado por: \\ // \\ // Maria Mafalda Sousa - MMCCE \\ // \\ // \\ // Triangulação 2D de Delaunay em pontos obtidos por uma imagem BMP. \\ // \\ // \\ #################################################################*/ #include "vtkvectortext.h" #include "vtkbmpreader.h" #include "vtkimageconstantpad.h" #include "vtkimagetostructuredpoints.h" #include "vtkstructuredpoints.h" #include "vtkimageactor.h" #include "vtkmath.h" #include "vtkpoints.h" #include "vtkpointdata.h" #include "vtkcellarray.h" #include "vtkpolydata.h" #include "vtkpolydatamapper.h" #include "vtkdelaunay2d.h" #include "vtkdatasetmapper.h" #include "vtkactor.h" #include "vtkproperty.h" #include "vtkrenderer.h" #include "vtkrenderwindow.h" #include "vtkrenderwindowinteractor.h" int main( int argc, char *argv[] )

24 24 { // Leitura do ficheiro BMP vtkbmpreader *imagein = vtkbmpreader::new(); imagein->setfilename("c:\\windows\\ambiente de trabalho\\trabalho VTK\\TDelaunay2D_1\\ice1.bmp"); // Criação do actor para imagem vtkimageactor *imgactor = vtkimageactor::new(); imgactor->setinput(imagein->getoutput()); // Extrai o número de componentes escalares dos pontos da imagem vtkimageconstantpad *pad = vtkimageconstantpad::new(); pad->setinput(imagein->getoutput()); pad->setoutputnumberofscalarcomponents(3); pad->setconstant(0); // Criar um conjunto de pontos estruturados a partir da imagem // e do número de componentes. vtkimagetostructuredpoints *i2sp1 = vtkimagetostructuredpoints:: New(); i2sp1->setinput(imagein->getoutput()); i2sp1->setvectorinput(pad->getoutput()); vtkstructuredpoints *ppoints = i2sp1->getoutput(); ppoints->update(); int n = ppoints->getnumberofpoints(); vtkdataarray *ptscalars;

25 25 ptscalars = (ppoints->getpointdata())->getscalars(); float rgb[3]; float x[3]; printf("\n n=%d", n); printf("\n size=%d", ptscalars->getsize()); vtkmath *math = vtkmath::new(); vtkpoints *points = vtkpoints::new(); vtkcellarray *polys = vtkcellarray::new(); register int i; // Criação de uma polydata com os pontos da imagem for (i = 0; i < n; i++) { } ppoints->getpoint(i, x); ((ppoints->getpointdata())->getscalars())->gettuple(i, rgb); points->insertpoint(i, x[0], x[1], (rgb[0]*20+rgb[1]*59+rgb[2]*11)/100); polys->insertnextcell(1); polys->insertcellpoint(i); // Introdução da Polydata vtkpolydata *profile = vtkpolydata::new(); profile->setpoints(points); profile->setverts(polys); // Criação do actor de entrada relativo ao mapa de pontos

26 26 vtkpolydatamapper *mappoints = vtkpolydatamapper::new(); mappoints->setinput(profile); vtkactor *actorpoints = vtkactor::new(); actorpoints->setmapper(mappoints); (actorpoints->getproperty())->setcolor(0, 0, 1); // Triangulação 2D Delaunay a partir dos pontos. vtkdelaunay2d *del = vtkdelaunay2d::new(); del->setinput(profile); del->settolerance(0.1); // Criação o actor de saída vtkdatasetmapper *map = vtkdatasetmapper::new(); map->setinput(del->getoutput()); // map->setinput(ppoints); vtkactor *triangulation2d = vtkactor::new(); triangulation2d->setmapper(map); (triangulation2d->getproperty())->setcolor(1, 0, 0); // Criação de dados de texto vtkvectortext *text1 = vtkvectortext::new(); text1->settext("imagem BMP"); vtkvectortext *text2 = vtkvectortext::new(); text2->settext("pontos"); vtkvectortext *text3 = vtkvectortext::new();

27 27 text3->settext("triangulacao"); // Mapeação dos vectores de texto vtkpolydatamapper *textmapper1 = vtkpolydatamapper::new(); textmapper1->setinput(text1->getoutput()); vtkpolydatamapper *textmapper2 = vtkpolydatamapper::new(); textmapper2->setinput(text2->getoutput()); vtkpolydatamapper *textmapper3 = vtkpolydatamapper::new(); textmapper3->setinput(text3->getoutput()); // Criação do actor de texto vtkactor *textactor1 = vtkactor::new(); textactor1->setmapper(textmapper1); (textactor1->getproperty())->setcolor(0, 0, 0); vtkactor *textactor2 = vtkactor::new(); textactor2->setmapper(textmapper2); (textactor2->getproperty())->setcolor(0, 0, 0); vtkactor *textactor3 = vtkactor::new(); textactor3->setmapper(textmapper3); (textactor3->getproperty())->setcolor(0, 0, 0); // Construção de renderers vtkrenderer *ren1= vtkrenderer::new();; ren1->addactor(textactor1); ren1->setbackground(1, 1, 1); ren1->setviewport(0, 0.45, 0.33, 1);

28 28 vtkrenderer *ren4= vtkrenderer::new();; ren4->addactor(imgactor); ren4->setbackground(1, 1, 1); ren4->setviewport(0, 0, 0.33, 0.70); vtkrenderer *ren2= vtkrenderer::new(); ren2->addactor(textactor2); ren2->setbackground(1, 1, 1); ren2->setviewport(0.33, 0.60, 0.66, 1); vtkrenderer *ren5= vtkrenderer::new(); ren5->addactor(actorpoints); ren5->setbackground(1, 1, 1); ren5->setviewport(0.33, 0, 0.66, 0.70); vtkrenderer *ren3= vtkrenderer::new(); ren3->addactor(textactor3); ren3->setbackground(1, 1, 1); ren3->setviewport(0.66, 0.45, 1, 1); vtkrenderer *ren6= vtkrenderer::new(); ren6->addactor(triangulation2d); ren6->setbackground(1, 1, 1); ren6->setviewport(0.66, 0, 1, 0.70); // renderwindow vtkrenderwindow *renwin1 = vtkrenderwindow::new(); renwin1->addrenderer(ren1); renwin1->addrenderer(ren2); renwin1->addrenderer(ren3); renwin1->addrenderer(ren4); renwin1->addrenderer(ren5);

29 29 renwin1->addrenderer(ren6); renwin1->setsize(1024, 500); // Janela de interação vtkrenderwindowinteractor * interactor1 = vtkrenderwindowinteractor::new(); interactor1->setrenderwindow(renwin1); renwin1->render(); interactor1->start(); // apagar os objectos construídos math->delete(); points->delete(); polys->delete(); profile->delete(); del->delete(); map->delete(); ren1->delete(); ren2->delete(); ren3->delete(); ren4->delete(); ren5->delete(); ren6->delete(); renwin1->delete(); interactor1->delete(); } return 0;