vision por computadora procesamiento de imagenes con vtk pfc_i_berzal.pdf

Desarrollodealgoritmosdeprocesamiento de imgenesconVTK

Autor:IgnacioBerzalMorenoTutor:CarlosPlateroDueas

Hace unos cuantos aos ya que entr en la Universidad (ms de los que me gustara), con un propsito: llegar a ser ingeniero. En ese momento pareca una meta muy lejana pero...por fin ha llegado el momento! Tras todos estos aos de estudios, este proyecto es el encargado de poner fin a esta etapa de mi vida.

Quiero dedicar este proyecto a toda la gente que me ha apoyado durante estos aos, y que ha confiado en mi, a mis padres, a mi novia Paloma (siempre ests ah), y a todos mis amigos (ellos saben quienes son). Tambin quiero dedicrselo a todos los compaeros de universidad con los que he compartido estos aos de clases, exmenes, prcticas, y agobios varios, y en especial a mis compaeros del GVA, Nuria, Nacho, David, Laura, Isaac y Mihai, con los que ms he sufrido este ltimo ao. Mencin especial por supuesto, para mi tutor en este proyecto Carlos Platero.

GRACIAS A TODOS!!!!! Nacho

Resumen

Este proyecto queda englobado en el conjunto de las lneas de investigacin del Grupo de Visin Artificial (GVA) de la Escuela Universitaria de Ingeniera Tcnica Industrial de la UPM, perteneciendo a la ctedra del ELAI de dicha escuela. El objetivo principal de este grupo es el desarrollo de aplicaciones software para el procesamiento de imgenes biomdicas.

Mediante el uso de la informtica se desarrollan aplicaciones de

procesamiento de imgenes que resuelven muchos problemas al profesional de la salud a la hora de elaborar un diagnstico fiable. Es en este campo donde se desarrolla el presente proyecto, en la implementacin y anlisis de algoritmos de visin que permitan procesar de forma adecuada imgenes biomdicas por computador.

Para lograr estos objetivos se ha empleado principalmente la herramienta

software VTK, aplicada a la programacin con C++. Tambin se trata de exponer la tcnica de modelado UML, muy til para el proceso de creacin de aplicaciones.

La realizacin de este trabajo tuvo lugar durante los aos 2003 y 2004, y cuenta con diversas lneas que seguirn siendo fructferas en el futuro.

Abstract

This project is included in the group of the lines of investigation of the Group of Artificial Vision (GVA) of the Escuela Universitaria de Ingeniera Tcnica Industrial of the UPM, belonging to the class of the ELAI of this school. The main objective of this group is the development of applications software for the processing of biomedical images.

By means of the computer science's use applications of processing of images

are developed that solve many problems to the professional of the health when elaborating a reliable diagnosis. It is in this field where the present project is developed, in the implementation and analysis of algorithms of vision that allow to process in way appropriate biomedical images for computer.

To achieve these objectives mainly the tool software VTK it has been used,

applied to the programming with C++. It is also to expose the technique of modeling UML, very useful for the process of creation of applications.

The realization of this work took place during the years 2003 and 2004, and it

has diverse lines that will continue being fruitful in the future.

GVA-ELAI-UPMPFC0081-2004

ndice

1 Introduccin...........................1

1.1Objetivos..................................... ..........................................21.2Sumariodelproyecto.......................... .................................3

2 Estadodelatcnica................5

2.1Herramientasdevisualizacindeimgenes...... ................5 2.1.1Matlab...................................... ...................................................5 2.1.1.1ProcesadodeimgenesconMATLAB............ ..............7

2.1.2SDC......................................... ....................................................72.1.3VTK......................................... ....................................................8

2.1.3.1VisualizacinconVTK........................ ..........................92.1.4ParaView.................................... .................................................92.1.5ITK......................................... ....................................................112.1.6OpenMoxis.................................... ............................................122.1.7MPI......................................... ...................................................13


3 FuncionamientodeVTK........15

3.1InstalacindeVTK............................. ..................................16 3.1.1Instalacinbinaria............... .....................................................16 3.1.2Instalacindelcdigofuente..... .............................................173.2FuncionamientoenC++deVTK................... ......................17 3.2.1CMake............................ .........................................................17 3.2.2ArquitecturadeVTK............... ..................................................18 3.2.2.1Graphicsmodel........................... ................................19 3.2.2.2Visualizationmodel...................... ................................20 3.2.2.2.1Ejecucindel pipeline.....................................23 3.2.2.2.2Procesamientodelaimagen............. .............24 3.2.3Creacindeunaaplicacin................... ....................................243.3Ejemplos....................................... ........................................25

3.3.1Renderizacindeuncilindro.................... ..................................253.3.2Renderizacindeuncono........................ .................................273.3.3Manipulacindeluces........................... .....................................30

4 Fasesdelareconstruccin3D....................................................37

4.1Conversindeldominiodeadquisicinalmallad o(marchingcubes)................................... ....................................38

4.2Reduccindepuntosdemallado................ ......................40


4.3Suavizadodelmallado.......................... ..............................41

5 Aplicaciones sobre una piladeimgenesdelconfocal............45

5.1Desarrollodelpipeline........................ .................................465.2Leerlosdatosdelapiladeimagen........... ........................475.3Trasladarislas............................... ......................................485.4Seleccionarunasuperficie.................... .............................505.5Remuestreodevolumen......................... ...........................525.6Alisarlosdatosdevolumen................... ...........................535.7Generartringulos............................ ..................................555.8Reducirelnmerodetringulos............... ........................555.9Alisarvrticesdetringulos................. .............................575.10Generarejemplares........................... ................................585.11Generarstripsdetringulos................. ...........................605.12Escribirtringulosaunfichero............. ..........................605.13Ejecutarelpipeline......................... ..................................615.14Especificarparmetrosparaelpipeline...... ...................615.15Ejemplo....................................... ........................................62


6 Combinacin de la difusinisotrpica y anisotrpica en elprocesamientodeimgenes........69

6.1Introduccinalfiltradodedifusin.......... .........................696.2Difusinanisotrpicaderealcedelacoherenci alocal...716.3Condicionesdedifusinanisotrpicaeisotrpi cadeCED.....................................................................................................756.4Combinacindeladifusinisotrpicayanisotr pica....76

6.4.1 Resultados de difusin isotrpica y anisotrpica.Ejemplos............................................................................................77

7 Aplicacin del filtrado dedifusin con imgenes JPG y PIC.........................................................83

7.1ModeladoUML.................................. ..................................83 7.1.1Introduccin.................................. .............................................83 7.1.2Modeladovisual.............................. ..........................................85

7.1.3QuesUML?................................. .........................................857.1.4DiagramasUML................................ ........................................867.1.5Procesodedesarrollo.......................... .....................................89


7.2LaherramientaRationalRose.................. .........................917.3Documentacindelaaplicacindifusin2D3D... ............91

7.3.1Visinyalcancedelaaplicacin.................. .............................927.3.1.1Requerimientosdelnegocio.................. ......................92

7.3.1.1.1Introduccin.............................. ....................92

7.3.1.1.2Oportunidaddelnegocio................... ..............93

7.3.1.1.3Objetivosesencialesycriteriosdexito....... .937.3.1.1.4Necesidadesdelosusuarios................... ......937.3.1.1.5Riesgosdelnegocio........................ ..............94

7.3.1.2Visindelasolucin........................ ............................947.3.1.2.1Visinglobal............................ .......................947.3.1.2.2Principalescaractersticas.................... .........957.3.1.2.3Suposicionesydependencias................... ....95

7.3.1.3Alcanceyrestricciones.......................... ......................967.3.1.3.1 Caractersticas principales en la primeraversin............................................. .............................96

7.3.1.3.2Mejorasenlassiguientesversiones............ ..967.3.1.3.3LimitacionesyExclusiones.................... ........97

7.3.2Casosdeuso................................... .........................................977.3.2.1Casodeusovisualizar2D................... .....................97

7.3.2.1.1Actor.................................... ...........................977.3.2.1.2Descripcin................................ ....................98

7.3.2.1.3Precondiciones............................ .................98

7.3.2.1.4Poscondiciones............................. ................98

7.3.2.1.5 Cursodexito........................... ....................98

7.3.2.1.6Cursoalternativo....................... ...................997.3.2.1.7Excepciones.............................. ...................997.3.2.1.8Prioridad............................. ..........................997.3.2.1.9Frecuenciadecasodeuso................... ........99


7.3.2.1.10Requerimientosespeciales................ ......1007.3.2.1.11Suposicionesdepartida................. .........1007.3.2.1.12Cuadroresumendelcasodeusovisualizar2D................................................ ...............................100

7.3.2.2Casodeusovisualizar3D................... ...................1017.3.2.2.1Actor.................................... .........................1017.3.2.2.2Descripcin................................ ..................101

7.3.2.2.3Precondiciones............................ ...............101

7.3.2.2.4Poscondiciones............................. ..............101

7.3.2.2.5Cursodexito........................... ...................102

7.3.2.2.6Cursoalternativo....................... .................1027.3.2.2.7Excepciones.............................. .................1027.3.2.2.8Prioridad............................. ........................1037.3.2.2.9Frecuenciadecasodeuso................... ......103

7.3.2.2.10Requerimientosespeciales................ ......1037.3.2.2.11Suposicionesdepartida................. .........1037.3.2.2.12Cuadroresumendelcasodeusovisualizar3D................................................ ...............................104

7.3.2.3Casodeusofiltrardifusin2D........... ....................1047.3.2.3.1Actor.................................... ........................1047.3.2.3.2Descripcin................................ ..................105

7.3.2.3.3Precondiciones............................ ...............105

7.3.2.3.4Poscondiciones............................. ..............105

7.3.2.3.5Cursodexito........................... ...................105



7.3.2.3.10Requerimientosespeciales................ ......1077.3.2.3.11Suposicionesdepartida................. .........1077.3.2.3.12Cuadroresumendelcasodeusofiltrardifusin2D......................................... ..........................107

7.3.2.4Casodeusofiltrardifusin3D........... ....................1087.3.2.4.1Actor.................................... .........................1087.3.2.4.2Descripcin................................ ..................108

7.3.2.4.3Precondiciones............................ ...............109

7.3.2.4.4Poscondiciones............................. ..............109

7.3.2.4.5Cursodexito........................... ...................109


7.3.2.4.10Requerimientosespeciales................ ......1117.3.2.4.11Suposicionesdepartida................. .........1117.3.2.4.12Cuadroresumendelcasodeusofiltrardifusin3D........................................ ..........................111

7.4CreacindelaaplicacinmedianteRationalRos e.......1127.4.1Creacindelproyecto.......................... ...................................1127.4.2Creacindecasosdeuso........................ ..............................1137.4.3Creacindeldiagramadeclasesdelmodelodean lisis......1147.4.4Creacindeldiagramadesecuencia.............. ........................1157.4.5Creacindeldiagramadeclasesdeldiseo....... ...................1167.4.6GeneracindecdigomedianteRationalRose.... ..................1177.4.7Ingenierainversa............................ ........................................121

7.4.7.1ConfiguracindeRationalRose:VisualC++ Add-in..1227.4.7.2Ingenierainversaconunaaplicacin.......... .............124

7.5Implementacindelcdigo..................... .........................1287.5.1Descripcindelasclasesempleadasenlaaplicacin.. .........129


7.5.1.1Clasevisualizacin2D.......................... .....................1297.5.1.2Clasevisualizacin3D.......................... .....................1327.5.1.3ClasefiltradoDifusin2D.................... ........................1387.5.1.4ClasefiltradoDifusin3D.................... ........................1437.5.1.5ClasevistaFiltradoDifusin2D3D............... ................150

7.5.2Ficheroprincipaldelaaplicacin............. ...............................155 7.5.3ArchivoCMakeLists.............................. ..................................156

8 Conclusiones......................157 8.1Principalesaportaciones...................... ............................1578.2Futurasmejoras............................... .................................158

9 Bibliografa.........................161

GVA-ELAI-UPMPFC0081-2004 1

1 Introduccin El marco del presente proyecto se desarrolla en un campo que ha ido ampliando horizontes en los ltimos aos, la Visin Artificial. La visualizacin se puede definir como el proceso de explorar, transformar y mostrar datos en forma de imgenes para comprender y apreciar adecuadamente las caractersticas de los mismos.

Se entiende por procesamiento digital de imgenes la manipulacin de las mismas a travs de un computador, de modo que la entrada y la salida del proceso sean imgenes. Por otro lado, la elaboracin de grficos por computador envuelve la creacin de imgenes a partir de descripciones de las mismas.

La disponibilidad de hardware dedicado, hace posible en la actualidad realizar

aplicaciones tanto de visualizacin de superficies como de visualizacin volumtrica en plataformas de relativo bajo coste.

I n t r o d u c c i n I g n a c i o B e r z a l M o r e n o

2 GVA-ELAI-UPMPFC0081-2004

El objetivo de utilizar el procesamiento digital de imgenes, es mejorar el

aspecto visual de ciertos elementos estructurales para el analista y proveer otras herramientas para su interpretacin, inclusive generando productos que puedan ser posteriormente sometidos a otros procesamientos.

ste rea ha generado un gran inters en las dos ltimas dcadas. Tanto la evolucin de la tecnologa de computacin, como el desarrollo de nuevos algoritmos para tratar seales bidimensionales y tridimensionales est permitiendo una gama de aplicaciones cada vez mayor.

Actualmente, estas tcnicas de Visin Artificial estn tomando un gran

impulso e importancia en el campo de la biomedicina, donde se estn estableciendo plataformas de investigacin en la lnea de desarrollar sistemas de visin artificial que permitan automatizar anlisis y diagnsticos de los profesionales de la biomedicina. Son muchas las tcnicas de procesamiento digital empleadas en el campo de la medicina. Estas van desde la mejora del contraste y la deteccin de contornos, hasta los ms complejos sistemas de reconocimiento de patrones y reconstrucciones tridimensionales.

Es en este campo donde se desarrolla el presente proyecto, en la

implementacin y anlisis de algoritmos de visin que permitan procesar de forma adecuada imgenes biomdicas por computador.

1.1 Objetivos

Los objetivos principales sobre los que profundizaremos a la largo de los captulos de este proyecto son los expuestos a continuacin:

Estudio de la herramienta de visualizacin y procesamiento de

imgenes VTK.

Anlisis de las fases de la reconstruccin de imgenes 3D, poniendo especial atencin en la tcnica de Marching Cubes.

Aplicacin de las libreras VTK para la reconstruccin 3D de

imgenes biomdicas provenientes de una pila de imgenes 2D del microscopio confocal.

Estudio de las tcnicas de filtrado de difusin isotrpica y anisotrpica

en el procesamiento de imgenes.

I g n a c i o B e r z a l M o r e n o I n t r o d u c c i n


Desarrollo de una aplicacin, implementada en C++ y usando las libreras VTK, que permita al usuario la visualizacin y/o filtrado de difusin de imgenes en dos y tres dimensiones. Esta aplicacin ser creada segn las tcnicas del modelado UML, mediante su herramienta software, Rational Rose.

Todos estos puntos estn ntimamente ligados, unos conducen a otros, para al

final obtener el objetivo principal, la aplicacin de las libreras de VTK para facilitar la correcta visualizacin y procesamiento de imgenes.

1.2 Sumariodelproyecto

Este proyecto consta de nueve captulos, los cules expondremos brevemente a continuacin.

En el segundo captulo se muestra una visin general de las herramientas

software de visualizacin de imgenes ms empleadas en la actualidad, como son MATLAB, VTK o ITK entre otras.

En el tercer captulo profundizamos en la herramienta de visualizacin VTK,

tratando desde su instalacin, hasta su arquitectura, viendo todas las posibilidades que ofrecen estas libreras, y finalizando con varios ejemplos de aplicaciones en C++.

El cuarto captulo trata sobre las fases de la reconstruccin de imgenes 3D,

centrndose en el algoritmo de conversin del dominio de adquisicin al mallado, llamado Marching Cubes. Tambin se tratarn las tcnicas de reduccin de puntos de mallado y el suavizado del mismo. Todo ello se har de forma terica, pero basndose en las libreras software VTK.

En el quinto captulo se describe una de las principales aplicaciones de VTK

sobre las que se centra este proyecto, la reconstruccin de una imagen en tres dimensiones a partir de una pila de imgenes en 2D obtenidas a travs de un microscopio confocal. Se mostrar un pipeline genrico, y se ver su resultado con un ejemplo, aplicado sobre una pila de imgenes de una neurona madre.

El sexto captulo lleva a cabo una exposicin terica sobre la combinacin de

la difusin isotrpica y anisotrpica en el procesamiento de imgenes, esto es, combinar ambos tipos de filtrado segn convenga, con el objetivo de mejorar el aspecto visual de una imagen, aplicando diferentes algoritmos.

El sptimo captulo es el ms extenso, y trata de aplicar todo lo introducido en

los captulos anteriores en la creacin de una aplicacin cuyo cdigo estar implementado en C++ y VTK. Esta aplicacin se crear siguiendo los pasos del

I n t r o d u c c i n I g n a c i o B e r z a l M o r e n o


modelado UML, mediante la herramienta software Rational Rose, por lo tanto, antes de llevar a cabo la exposicin detallada del proceso de creacin de la aplicacin, se har una introduccin sobre las bases de esta filosofa de trabajo. La aplicacin final permitir al usuario llevar a cabo la visualizacin y/o filtrado de difusin de imgenes en dos y tres dimensiones con formato JPG y PIC respectivamente.

El octavo captulo expresa las conclusiones finales, y en l se exponen las

principales aportaciones del proyecto, as como sus limitaciones y futuras mejoras. Por ltimo, en el noveno captulo se incluyen las referencias bibliogrficas

que se han empleado para la realizacin de este proyecto.


2 Estadodelatcnica

2.1Herramientasdevisualizacindeimgenes

Existen distintas herramientas para la visualizacin de imgenes mediante un soporte informtico. En este captulo trataremos con brevedad algunas de ellas.

2.1.1Matlab

MATLAB es un lenguaje de alto nivel que incluye herramientas de clculo numrico y visualizacin de imgenes. Es un programa de Mathworks orientado para realizar todo tipo de clculos con vectores y matrices. Tambin presenta la posibilidad de realizar grficos en dos y tres dimensiones.

MATLAB es una herramienta muy potente que realiza con gran precisin operaciones complejas. Se emplea en todo tipo de aplicaciones donde se trabaja con funciones matemticas o matrices. Su entorno grfico es simple y su aprendizaje no requiere gran esfuerzo, lo que hace que sea uno de los lenguajes ms empleados en el mbito cientfico.

E s t a d o d e l a t c n i c a I g n a c i o B e r z a l M o r e n o


Figura 2.1: Logo de MATLAB MATLAB posee unas libreras especializadas para distintos tipos de aplicaciones llamadas toolboxes. Estas toolboxes contienen una coleccin de funciones (M-files) que extienden el dominio de MATLAB para resolver problemas de mbitos particulares. Existen muchas reas de trabajo para las que hay disponibles toolboxes especficas, como por ejemplo el procesado de seales y de imgenes, la lgica difusa, los sistemas de control, etc. Tambin permiten llevar a cabo simulaciones usando diferentes parmetros, que permiten analizar el comportamiento de diferentes sistemas.

Figura 2.2: Interfaz de MATLAB

I g n a c i o B e r z a l M o r e n o E s t a d o d e l a t c n i c a


2.1.1.1ProcesadodeimgenesconMATLAB

MATLAB posee una toolbox de procesado de imgenes que proporciona un conjunto de funciones y herramientas para el anlisis y visualizacin de imgenes digitales, as como para el desarrollo de algoritmos. Esta toolbox proporciona a cientficos, investigadores e ingenieros un conjunto flexible de herramientas para resolver problemas complejos en el tratamiento de imgenes. Muchas de las funciones de esta toolbox estn implementadas de manera abierta, es decir podemos acceder a su cdigo fuente y alterar los algoritmos segn nuestras necesidades, o incluso desarrollar otros nuevos. Mediante esta toolbox podemos restaurar o degradar las imgenes, as como extraer y analizar datos de las mismas. Estas tcnicas resultan muy tiles en campos como la astronoma, el control remoto, la industria aeroespacial, la medicina y la bioingeniera.

2.1.2SDC

SDC Morphology Toolbox para MATLAB es un software para el anlisis de imgenes y procesamiento de seales. Est compuesto por una familia de filtros discretos, no lineales. stos filtros, llamados operadores morfolgicos, son muy tiles para restauracin, segmentacin y anlisis cuantitativo de imgenes y seales.

Figura 2.3: Logo de SDC

Las SDC Morphology Toolbox trabajan con escala de grises e imgenes binarias (o seales). As, la mayora de los operadores realizan el procesamiento en escala de grises o imagen binaria y la seleccin de la apropiada del algoritmo automticamente. Las imgenes (o seales) pueden ser representadas por los formatos: binario, 8- bscula de bit-gris y 16-bscula de bit-gris, donde cada pxel es representado, respectivamente, por un tipo de datos lgico uint8, un uint8 y uint16. Los operadores morfolgicos pueden ser escritos jerrquicamente a partir de dos operadores elementales: dilatacin y erosin. SDC tiene unas herramientas muy eficientes para la dilatacin y erosin. Sin embargo, para obtener ms eficiencia, varios operadores son tratados tambin por algoritmos rpidos especiales. Algunos de estos operadores son de transformacin de la distancia, reconstruccin,



etiquetando y apertura de reas. Dilataciones y erosiones son parametrizadas por imgenes particulares (o seales), llamadas elementos estructurantes.

La SDC Morphology Toolbox puede funcionar bajo 3 plataformas: Win

95/98/NT, Linux y Solaris. SDC depende de la versin de Matlab 5, o superior. No depende de ninguna otra toolbox.

2.1.3VTK

VTK (Visualization Toolkit) es un conjunto de libreras de cdigo y distribucin libres destinadas a la visualizacin y el procesado de imgenes, basadas en la programacin orientada a objetos. Son muy amplias y complejas, pero an as, estn diseadas para ser sencillas de emplear con cualquier lenguaje de programacin orientado a objetos, como pueden ser C++, Java, Tcl. Son capaces de realizar operaciones sobre imgenes en dos y tres dimensiones y de generar modelos en las mismas con pocas lneas de cdigo. Debido a su gran potencia, se hacen necesarios amplios recursos de memoria en el PC para poder aprovechar en su totalidad sus funcionalidades.

Figura 2.4: Logo de VTK

El modelo grfico de VTK posee un nivel de abstraccin mucho mayor que el de otras libreras de renderizacin de imgenes como OpenGL o PEX. Esto se traduce en una mayor sencillez a la hora de implementar aplicaciones grficas o de visualizacin con VTK. Adems, las aplicaciones creadas empleando VTK pueden ser escritas directamente en Tcl, Java, Pitn o C++, lo que aumenta y facilita la posibilidad de implementar aplicaciones en poco tiempo.

Por otra parte, este software es un sistema de visualizacin que no slo nos permite visualizar geometra, sino que adems soporta una amplia variedad de algoritmos de visualizacin, incluyendo mtodos escalares, vectoriales, tensores, de textura y volumtricos, adems de otras modernas tcnicas de modelado, como la reduccin poligonal, el contorneado, la tcnica de marching cubes, etc.



2.1.3.1 VisualizacinconVTK

En VTK, el procesamiento de los datos se realiza a travs de un pipeline. Una vez los datos entran en el pipeline, pueden ser afectados por multitud de procesos o transformaciones. Para leer los datos se debe emplear el reader (lector) apropiado para el tipo de dato. Una vez hecho esto, pueden aplicrseles diferentes tipos de filtros, que alteren los datos de la manera deseada, o definir el tipo de renderizacin entre otras muchas cosas. VTK es la herramienta principal empleada en la realizacin de este proyecto, por lo que profundizaremos en su empleo y caractersticas en captulos posteriores, aunque como muestra de sus posibilidades, incluiremos a continuacin un ejemplo de imgen obtenida a partir de estas libreras:

Figura 2.5: Figura procesada con VTK

2.1.4 ParaView

ParaView es una aplicacin diseada debido a la necesidad de visualizar archivos con gran cantidad de datos. Los objetivos del proyecto de ParaView, incluyen lo siguiente:

Desarrollar un cdigo abierto para la visualizacin multiplataforma. Soportar lo modelos de programacin distribuda para procesar conjuntos de datos complejos. Crear una interface de usuario abierta, flexible e intuitiva.



Desarrollar una arquitectura extensible basada en estndares abiertos.

Figura 2.6: Logo de Paraview

ParaView puede funcionar tanto en sistemas distribuidos en paralelo y de memoria compartida como en sistemas de procesador nico. Puede emplearse bajo Windows, Linux o Unix.

ParaView utiliza VTK como base de procesamiento de datos y motor de la

renderizacin y visualizacin. Posee una interfaz escrita mediante una mezcla nica de Tcl/Tk y de C++.

Figura 2.7: Interfaz de Paraview



El objetivo principal de la creacin de ParaView es el desarrollo de una herramienta que emplee el procesamiento distribuido de memoria de manera paralela y escalable. El proyecto incluye algoritmos de trabajo en paralelo, infraestructura de entrada y salida, ayuda, y dispositivos de demostracin. Una caracterstica significativa es que todo el software desarrollado est escrito en cdigo abierto, lo que implica que ParaView est disponible gratuitamente.

2.1.5 ITK

ITK es una herramienta software de cdigo libre para la ejecucin del registrado y segmentacin. La segmentacin es el proceso de identificar y clasificar los datos encontrados en una representacin muestreada digitalmente. Tpicamente, la representacin muestreada ser una imagen adquirida mediante instrumentacin mdica, como el CT o el escner MRI. El registrado consiste en alinear o desarrollar correspondencias entre los datos. Por ejemplo, en el mbito de la medicina, un escner CT puede ser alineado con un MRI para combinar la informacin proporcionada por ambos.

Figura 2.8: Logo de ITK

ITK est implementado en C++, y es multiplataforma gracias al empleo de la aplicacin CMake para dirigir el proceso de compilacin. Adems, un proceso automtico de interpretacin genera interfaces entre C++ y otros lenguajes como Tcl, Java, y Python. Esto permite a los programadores desarrollar aplicaciones en cualquiera de estos lenguajes.



Figura 2.9: Ejemplo de imagen binarizada con ITK Gracias a que ITK es un software de cdigo libre, cualquier persona puede contribuir a depurarlo, mantenerlo e incluso extenderlo. ITK usa un modelo de desarrollo de software que se conoce como programacin extrema. Este estilo de programacin cambia la metodologa clsica por un proceso simultneo e iterativo de diseo, implementacin y testeado. La clave est en la comunicacin entre los miembros de la comunidad de usuarios de ITK, que ayuda a una rpida evolucin del software. El proceso de testeado es el que hace el software estable.

2.1.6 OpenMoxis

Podramos decir que OpenMosix se cre como una modificacin de Linux, ya que consiste en un conjunto de parches aadidos a su kernel, que permiten una distribucin automtica y transparente de la carga de tareas a lo largo de las mquinas que forman el cluster. Y todo ello sin tener que modificar el cdigo del programa.

Figura 2.10: Logo de OpenMoxis



Con OpenMosix se puede iniciar un proceso en una computadora y

comprobar si se ejecuta en otra, en el seno del cluster. Cada proceso tiene su nico nodo raz (UHN, unique home node) que se corresponde con el que lo ha generado.

El concepto de migracin se refiere al hecho de que un proceso se divide en

dos partes: la parte del usuario y la del sistema. La parte, o rea, de usuario ser movida al nodo remoto, mientras el rea de sistema espera en el nodo raz. OpenMosix se encargar de establecer la comunicacin entre estos dos procesos, pudiendo migrarse cualquiera proceso a cualquier nodo del cluster de forma completamente transparente al proceso migrado (mecanismo de migracin).

La idea de este modelo es que la distribucin de tareas en el cluster la determina OpenMosix de forma dinmica, conforme se van creando tareas. Cuando un nodo est demasiado cargado, las tareas que se estn ejecutando migran a cualquier otro nodo del cluster. As desde que se ejecuta una tarea hasta que sta finaliza, podr migrar de un nodo a otro, sin que el proceso sufra mayores cambios.

El empleo de OpenMoxis tiene como ventajas el hecho de que no son necesarias modificaciones en el cdigo, ni la instalacin de paquetes extra, aunque tambin tiene varios puntos negativos, entre los que estn su dependencia del kernel (ncleo del sistema operativo), limitaciones de funcionamiento en los procesos de migracin, y ciertos problemas con la memoria compartida entre procesos.

2.1.7 MPI

MPI es un estndar creado por un amplio conjunto de expertos y usuarios con el objetivo de definir una infraestructura comn y una semntica especfica de interfaz de comunicacin. De esta forma los productores de software de procesamiento en paralelo pueden implementar su propia versin de MPI siguiendo las especificaciones de este estndar, con lo cual mltiples implementaciones de MPI cambiaran solamente en factores tales como la eficiencia de su implementacin y herramientas de desarrollo, pero no en sus principios bsicos.

Figura 2.11: Logo de MPI



Actualmente existen diferentes implementaciones de MPI, algunas son comerciales y otras son de libre circulacin y adaptables a mltiples arquitecturas. Una de ellas es MPICH, que es un ambiente de desarrollo y programacin de MPI orientado a arquitecturas heterogneas de ordenadores distribuidos en una red local. Con MPICH, tanto un "cluster" dedicado, como una simple red local de ordenadores, pueden actuar como un ordenador multiprocesador.

Figura 2.12: Logo MPICH


3 FuncionamientodeVTK

The Visualization Toolkit (VTK) es un conjunto de libreras de cdigo libre basadas en la programacin orientada a objetos. Estn destinadas a la visualizacin y el procesamiento de imgenes, as como a la creacin de objetos grficos en 2D y 3D mediante el PC.

VTK esta constituido por dos subsistemas, una librera de clases compilada en C++ y varios interpretes que permiten la manipulacin de estas clases compiladas en lenguajes Java, Tcl/Tk y Python. Por tanto las aplicaciones de VTK pueden ser escritas directamente en cualquiera de estos lenguajes.

Esta software es un sistema de visualizacin que no slo nos permite

visualizar geometra, sino que adems soporta una amplia variedad de algoritmos de visualizacin y otras modernas tcnicas de modelado.

Debido a su gran potencia, se hacen necesarios amplios recursos de memoria en el PC para poder aprovechar en su totalidad sus funcionalidades.

Funcionamiento de VTK Ignacio Berzal Moreno


3.1InstalacindeVTK

Hay dos tipos de instalacin bajo el entorno de Windows. La primera es una instalacin binaria, con la que podremos desarrollar aplicaciones en C++, Java, Tcl y Python para compilar y lincar. La segunda es una instalacin completa del cdigo fuente, que requiere la compilacin del cdigo fuente de VTK (para generar libreras C++) y del cdigo envolvente de VTK (para generar ejecutables en Java, Tcl y Python). De los dos tipos de instalaciones, la instalacin binaria es mas sencilla y por tanto la recomendada.

3.1.1Instalacinbinaria

Para instalar las libreras y ejecutables de VTK hacemos doble clic sobre el icono setup.exe que se encuentra en el CD-ROM, comenzando el proceso de instalacin. Aparecer la siguiente ventana:

Figura 3.1 : Instalacin binaria

Ignacio Berzal Moreno Funcionamiento de VTK


En esta ventana tendremos que elegir las partes de VTK que necesitemos instalar dependiendo del uso que vayamos a hacer del programa. As mismo, el VTK4.2 y el CMake sern instalados automticamente. 3.1.2 Instalacindelcdigofuente Esta instalacin es necesaria para desarrollar aplicaciones en C++, crear nuevas libreras y extenderlas a VTK, y para alterar o mejorar las ya existentes. Primero debemos asegurarnos de tener un compilador de C++ instalado en el ordenador y, dependiendo de los lenguajes que vayamos a usar, compiladores para estos lenguajes (Java, Tcl\Tk o Python). Despus copiamos el cdigo fuente directamente de la carpeta VTK-src-windows del CD al disco duro. Finalmente, compilaremos este cdigo fuente con el compilador de C++, con la ayuda de la aplicacin CMake. Este proceso puede durar varias horas. Sin embargo, esta instalacin tiene como beneficio la mejora del tiempo de compilacin. Como hemos indicado, para compilar VTK es necesario instalar previamente CMake. Para ello hacemos doble clic sobre el icono CMSetup.exe que se encuentra dentro de la carpeta Binaries localizada en la carpeta CMake del CDROM, iniciando el proceso de instalacin. 3.2 FuncionamientoenC++deVTK 3.2.1CMake Para poder ejecutar un cdigo fuente escrito en C++ con VTK es necesario el uso de la aplicacin CMake. El CMake es una herramienta multiplataforma de cdigo libre empleada para configurar y dirigir el proceso de construccin de aplicaciones. Ficheros independientes llamados CMakeLists.txt se usan para describir el proceso de construccin y establecer las dependencias. Cuando ejecutamos CMake, se generan los ficheros necesarios, dependiendo del compilador y sistema operativo que estemos utilizando. Esto sirve para compilar VTK fcilmente, y trabajar con herramientas propias de la plataforma en la que estemos trabajando. Para hacer funcionar el CMake hacemos doble click en el icono CMakeSetup.exe y a continuacin aparecer el GUI que se muestra en la figura 3.2. El CMake necesita tres datos, que deben ser indicados antes de su ejecucin: el compilador que va a ser empleado, la direccin del cdigo fuente y la direccin donde se generarn el cdigo objeto, las libreras y los binarios producidos en la compilacin.



Figura 3.2: GUI de CMake Una vez indicados estos datos, hacemos clic sobre configure para iniciar el proceso. El CMake lee el fichero CMakeLists.txt de mayor nivel encontrado en la direccin de la fuente, determina la configuracin del sistema y localiza las fuentes. Entonces producir un fichero CMakeCache.txt en la direccin que le hallamos indicado. Cuando termina la configuracin se le comunica al usuario. Si se quieren cambiar valores del cach, el CMake proporciona una GUI para hacerlo. Una vez hechos los cambios requeridos, pulsamos configure de nuevo. Finalmente se producirn los workspaces, makefiles y todo lo necesario para controlar la construccin de los procesos por parte del compilador. Una vez hecho esto ya podemos cargar el fichero workspace generado (.dsw) y crear nuestra aplicacin. 3.2.2ArquitecturadeVTK The Visualization Toolkit es un sistema orientado a objetos. La clave para utilizar VTK eficientemente es tener un buen conocimiento de los modelos de objetos fundamentales. Con esto, es mucho ms fcil combinar estos objetos para construir aplicaciones. VTK est constituido por dos modelos de objetos: Graphics Model y Visualization Model.



3.2.2.1Graphicsmodel Los objetos principales que componen el graphics model son los siguientes:

- vtkActor, vtkActor2D, vtkVolume ( subclases de vtkProp y vtkProp3D) - vtkLight - vtkCamera - vtkProperty, vtkProperty2D - vtkMapper, vtkMapper2D (subclases de vtkAbstractMapper) - vtkTransform - vtkLookupTable, vtkColorTransferFunction (subclases de

vtkScalarsToColors) - vtkRenderer - vtkRenderWindow - vtkRenderWindowInteractor

Al combinar estos objetos creamos una escena. Los props representan las cosas que vemos en escena. Los que son utilizados en 3D son del tipo vtkProp3D y los representados es 2D son del tipo vtkActor2D. Los props no representan directamente su geometra, sino que sta es referida a mappers, los cuales son responsables de la representacin de datos (entre otras cosas). Los props tambin se refieren a una propiedad del objeto. La propiedad del objeto controla la apariencia del prop (color, efecto de luces, representacin de la renderizacin, etc). Los actores y volmenes tienen un objeto de transformacin interna (vtkTransform). Este objeto encapsula una matriz de transformacin 4x4 que controla la posicin, orientacin y escala del prop. Las luces (vtkLight) se usan para representar y manipular la iluminacin de la escena. Solo se emplean en 3D. La cmara (vtkCamera) controla cmo la geometra 3D es proyectada en imagen 2D durante el proceso de renderizacin. Tiene varios mtodos para posicionar y orientar. Adems controla la perspectiva de la proyeccin y la visin estreo. Esto no es necesario en 2D. El mapper (vtkMapper) junto con el lookup table (vtkLookupTable) son usados para transformar y renderizar geometra. El mapper proporciona la interfaz entre el pipeline de visualizacin y el graphics model. VtkLookupTable es una subclase de vtkScalarsToColors, tambin lo es vtkColorTransferFunction, la cual se usa para renderizar volmenes. Las subclases de vtkScalarsToColors son responsables de mapear los valores de los datos a color.



Los renderers (vtkRenderer) y las render windows (vtkRenderWindow) se usan para dirigir la interfaz entre la mquina grfica y el sistema de ventanas del ordenador. La render window es la ventana del ordenador donde el renderer crea el objeto. Varios renderers pueden actuar sobre una misma ventana de renderizacin. Adems se pueden crear mltiples render windows. Una vez creados los objetos en la ventana de renderizacin, existen varios mtodos en VTK para interactuar con los datos de la escena. Uno de ellos es el objeto vtkRenderWindowInteractor, que es una herramienta simple para manipular la cmara, mover objetos, etc. Muchos de estos objetos tienen subclases que especializan el comportamiento del objeto. 3.2.2.2Visualizationmodel La funcin del pipeline grfico consiste en transformar datos grficos en imgenes, y la del pipeline de visualizacin en crear esos datos grficos a partir de la informacin necesaria; es decir, el pipeline de visualizacin es el encargado de construir la representacin geomtrica que ser renderizada por el pipeline grfico. VTK emplea dos tipos bsicos de objetos en esta tarea:

- vtkDataObject - vtkProcessObject

Los data objects representan datos de varios tipos. La clase vtkDataObject puede interpretarse como un conjunto genrico de datos. A los datos que tienen una estructura formal se les llama dataset (de la clase vtkDataSet). Los objetos dataset en VTK se muestran en la figura 3.3. Los data objects consisten en una estructura (de puntos y celdas) geomtrica y topolgica, as como en unos atributos de datos que pueden ser, por ejemplo, escalares o vectores. Los atributos de datos pueden ser asociados con los puntos o celdas del dataset. Las celdas son agrupaciones topolgicas de puntos, que forman las unidades del dataset y se usan para interpolar informacin entre puntos.



Figura 3.3: Datasets empleados por VTK

Los process objects, tambin llamados filtros, operan en los data objects para generar nuevos data objects. Representan los algoritmos del sistema. Process y data objects se conectan para formar los pipelines de visualizacin. Un ejemplo de ello es la figura 3.4, en la que las flechas representan la direccin del flujo de datos:



Figura 3.4: Pipeline de visualizacin Existen varios tipos importantes de process objects:

Figura 3.5: Process objects

Los fuentes son objetos que generan datos leyendo (reader objects) o construyendo uno o ms data objects (procedural source objects). Los filtros pueden tener varios data objects en la entrada, y generar uno o ms data objects en la salida. Los mappers transforman los data objects en datos grficos, los cuales son renderizados por la mquina grfica. Es necesario llevar a cabo varios pasos para la construccin del pipeline de visualizacin: Primero, la topologa se construye usando variaciones de los mtodos que asignan a la entrada de un filtro la salida de otro filtro. Por ejemplo, en C++ se hara de la siguiente forma:



aFilter->SetInput(anotherFilter->GetOutput() ); Segundo, debemos tener mecanismos para controlar la ejecucin del pipeline. Solo necesitaremos ejecutar las partes del pipeline necesarias para actualizar la salida. Tercero, el ensamblaje del pipeline requiere que slo aquellos objetos compatibles entre s puedan enlazarse con los mtodos SetInput() y GetOutput(). Finalmente, debemos decidir si conservar o no los data objects una vez que el pipeline es ejecutado. Los dataset de visualizacin suelen ser bastante grandes, lo que es necesario tener en cuenta para la aplicacin con xito de las herramientas de visualizacin. 3.2.2.2.1Ejecucindel pipeline El pipeline de visualizacin slo se ejecuta cuando los datos son requeridos para la computacin. La ejecucin del pipeline puede explicarse a partir de la siguiente figura:

Figura 3.5: Ejecucin del pipeline

Cuando el actor recibe una peticin de renderizacin se lo comunica a su mapper, y el mtodo Update() es enviado automticamente a travs del pipeline de visualizacin. La funcin del mtodo Update() es forzar la ejecucin del pipeline, con ello fuerza al reader a ejecutar y leer los datos del fichero indicado. Es decir, el mtodo Render() inicia la peticin de datos, la cual es comunicada a travs del pipeline. Dependiendo de que partes del pipeline no estn actualizadas, los filtros del pipeline son reejecutados, actualizando los datos al final del pipeline, que entonces son rederizados por el actor.



3.2.2.2.2Procesamientodelaimagen VTK tiene un extenso nmero de mtodos para el procesamiento de imgenes y renderizacin de volmenes. Los datos de imgenes 2D y 3D vienen dados por la clase vtkImageData. En un dataset de imagen los datos son ordenados en un vector regular alineado con los ejes. Mapas de bits y mapas de pxeles son ejemplos de datasets de imgenes 2D, y volmenes (pilas de imgenes 2D) lo son de datasets de imgenes 3D. Los process objects en un pipeline de imagen siempre tienen como entradas y salidas data objects de imagen. Debido a la naturaleza regular y simple de los datos, el pipeline de imagen tiene otros rasgos importantes. La renderizacin de volumen se usa para visualizar objetos 3D de la clase vtkImageData, y visores especiales de imgenes se usan para ver objetos 2D. La mayora de los process objets en el pipeline de imagen estn multiensamblados y son capaces de hacer fluir los datos por partes (para hacer un uso satisfactorio del lmite de memoria). Los filtros automticamente detectan el nmero disponible de procesos en el sistema y crean el mismo nmero de uniones durante la ejecucin; igualmente, separan automticamente los datos en partes que fluyen a travs del pipeline. 3.2.3Creacindeunaaplicacin Crear aplicaciones grficas con VTK es un proceso que consta de dos partes bsicas:

- Primero, es necesario construir un pipeline de datos para procesar los datos - Segundo, hay que crear los objetos grficos necesarios para interpretar esos

datos. Construir un pipeline quiere decir conectar fuentes (crear datos), filtros (procesar datos) y mappers (transformar datos en grficos). Estn disponible muchos tipos distintos de fuentes, filtros y mappers, dependiendo del tipo de datos que se estn procesando y de la funcionalidad deseada. Para crear objetos grficos los pasos tpicos pueden ser:

- Crear una ventada de renderizacin para trabajar en ella. - Crear un render. - Crear un interactor (que permite interactuar con los datos). - Crear uno o ms actores (cada uno de los cuales es unido a un mapper). - Renderizar. -

Adems, los objetos pueden ser transformados, pueden cambiarse sus propiedades materiales y/o pueden crearse luces, cmaras, mapas de textura, tablas de consulta y otros objetos grficos.



3.3Ejemplos

3.3.1Renderizacindeuncilindro

Este simple ejemplo muestra cmo crea un modelo poligonal de un cilindro, mediante un pipeline y una renderizacin bsicas: /*******************************************************************/ // Primero se incluyen ficheros de cabecera requeridos por las clases de VTK que //vamos a emplear:

#include"vtkCylinderSource.h"#include"vtkPolyDataMapper.h"#include"vtkActor.h"#include"vtkRenderer.h"#include"vtkRenderWindow.h"#include"vtkRenderWindowInteractor.h"#include"vtkProperty.h"#include"vtkCamera.h"

// Se declara la funcin principal:

intmain(intargc,char*argv[]){

// Creamos un modelo poligonal de un cilindro a partir de ocho esferas:

vtkCylinderSource*cylinder=vtkCylinderSource::New();cylinder->SetResolution(8);

// Creamos el mapper, responsable de convertir los datos geomtricos en datos //grficos:

vtkPolyDataMapper*cylinderMapper=vtkPolyDataMapper::Ne w();cylinderMapper->SetInput(cylinder->GetOutput());

// Creamos un actor para representar el cilindro. El actor dirige la renderizacin de //las primitivas grficas del mapper. Adems, establecemos el color, y lo rotamos //22.5 grados:

vtkActor*cylinderActor=vtkActor::New();cylinderActor->SetMapper(cylinderMapper);cylinderActor->GetProperty()->SetColor(1.0000,0.3882 ,0.2784);cylinderActor->RotateX(30.0);



cylinderActor->RotateY(-45.0);

// Creamos la estructura grfica. El renderer renderiza en la ventana de renderizacin. //El render window interactor captura las directrices del ratn y muestra la cmara y //punto de vista necesarios segn sus indicaciones:

vtkRenderer*ren1=vtkRenderer::New();vtkRenderWindow*renWin=vtkRenderWindow::New();renWin->AddRenderer(ren1);vtkRenderWindowInteractor*iren=

vtkRenderWindowInteractor::New();iren->SetRenderWindow(renWin);

// Aadimos el actor al renderer, y elegimos el color de fondo y el tamao de la //ventana:

ren1->AddActor(cylinderActor);ren1->SetBackground(0.1,0.2,0.4);renWin->SetSize(200,200);

// Acercamos la cmara mediante el mtodo Zoom ( ):

ren1->GetActiveCamera()->Zoom(1.5);renWin->Render();

// Comenzamos la renderizacin:

iren->Start();

// Liberamos todas las instancias que hemos creado:

cylinder->Delete();cylinderMapper->Delete();cylinderActor->Delete();ren1->Delete();renWin->Delete();iren->Delete();

return0;}

/*******************************************************************/

Como ya indicamos anteriormente, para poder ejecutar un cdigo fuente implementado en C++ es necesario emplear la aplicacin CMake. En este caso, el fichero CMakeLists.txt que deber incluirse ser el siguiente:



PROJECT (Rendering) INCLUDE (${CMAKE_ROOT}/Modules/FindVTK.cmake) IF (USE_VTK_FILE) INCLUDE(${USE_VTK_FILE}) ENDIF (USE_VTK_FILE) ADD_EXECUTABLE(Cylinder Cylinder.cxx) TARGET_LINK_LIBRARIES(Cylinder vtkRendering)

Una vez CMake ha generado los ficheros necesarios, el resultado de la ejecucin del programa ser la siguiente ventana, donde el cilindro podr girarse moviendo el ratn con el cursor sobre el cilindro y manteniendo el botn derecho presionado:

Figura 3.6: Renderizacin de un cilindro 3.3.2Renderizacindeuncono

Este ejemplo crea un modelo poligonal de un cono, y posteriormente lo renderiza en la pantalla. El cono realiza una rotacin de 360 grados y la aplicacin finaliza. Sigue la estructura bsica de fuente -> mapper -> actor -> renderer -> renderwindow, tpica de la mayora de los programas en VTK:



/*******************************************************************/ // Primero se incluyen ficheros de cabecera requeridos por las clases de VTK que //vamos a emplear:

#include"vtkConeSource.h"#include"vtkPolyDataMapper.h"#include"vtkRenderWindow.h"#include"vtkCamera.h"#include"vtkActor.h"#include"vtkRenderer.h"

// Se declara la funcin principal:


// Ahora creamos un objeto de la clase vtkConeSource y fijamos algunas de sus // propiedades. El objeto cone de la clase vtkConeSource creado, forma parte de un // pipeline de visualizacin ( es un process object fuente); genera datos que otros //filtros pueden procesar (su salida es del tipo vtkPolyData).

vtkConeSource*cone=vtkConeSource::New();cone->SetHeight(3.0);cone->SetRadius(1.0);cone->SetResolution(10);

// En este ejemplo finalizamos el pipeline con un process object tipo mapper //(pueden ser incluidos filtros intermedios entre el fuente y el mapper, como el // vtkShrinkPolyData). Creamos un objeto de la clase vtkPolyDataMapper para //generar primitivas grficas a partir de datos poligonales. Conectamos la salida del //cono fuente a la entrada del mapper.

vtkPolyDataMapper*coneMapper=vtkPolyDataMapper::New() ;coneMapper->SetInput(cone->GetOutput());

// Creamos un actor para representar el cono. El actor dirige la renderizacin de las // primitivas grficas del mapper. Un actor tambin puede controlar las propiedades // mediante la clase vtkProperty, e incluye una matriz de transformacin interna. // Seleccionamos como mapper de este actor al coneMapper creado anteriormente.

vtkActor*coneActor=vtkActor::New();coneActor->SetMapper(coneMapper);

// Creamos el Renderer y le asignamos los actores. Un renderer es como un portal de



// visualizacin. Es toda o parte de una ventana creada en la pantalla, y se encarga de // representar los actores que posee. Aqu tambin seleccionamos el color de fondo.

vtkRenderer*ren1=vtkRenderer::New();ren1->AddActor(coneActor);ren1->SetBackground(0.1,0.2,0.4);

// Finalmente creamos la ventana de renderizacin que aparecer en la pantalla. //Colocamos el renderer en la render window usando AddRenderer. Tambin // seleccionamos el tamao de la ventana, que ser de 300 x 300 pxeles.

vtkRenderWindow*renWin=vtkRenderWindow::New();renWin->AddRenderer(ren1);renWin->SetSize(300,300);

// Ahora giramos el cono 360 grados y lo renderizamos al mismo tiempo:

inti;for(i=0;iRender(); // Rotamos la cmara 1 grado:

ren1->GetActiveCamera()->Azimuth(1);}

// Liberamos todos los objetos creados. Todos son borrados usando el mtodo Delete( ).

cone->Delete();coneMapper->Delete();coneActor->Delete();ren1->Delete();renWin->Delete();

return0;}

/*******************************************************************/

El fichero CMakeLists.txt necesario para la ejecucin de CMake ser el siguiente: PROJECT (Cone)



INCLUDE (${CMAKE_ROOT}/Modules/FindVTK.cmake) IF (USE_VTK_FILE) INCLUDE(${USE_VTK_FILE}) ENDIF (USE_VTK_FILE) ADD_EXECUTABLE(Cone Cone.cpp) TARGET_LINK_LIBRARIES(Cone vtkRendering)

Una vez CMake ha generado los ficheros necesarios, el resultado de la ejecucin

del programa ser la siguiente ventana (el cono girar 360 grados, y despus se cerrar la ventana):

Figura 3.7: Renderizacin de un cono

3.3.3Manipulacindeluces En VTK se pueden manipular luces, cmaras, texturas, transparencias as como

muchos otros efectos de visualizacin. Este ejemplo demuestra el efecto de la luz especular sobre un conjunto de esferas:

/*******************************************************************/ // Primero se incluyen los ficheros de cabecera requeridos por las clases de VTK que //vamos a emplear:



#include"vtkSphereSource.h"#include"vtkPolyDataMapper.h"#include"vtkActor.h"#include"vtkRenderer.h"#include"vtkRenderWindow.h"#include"vtkRenderWindowInteractor.h"#include"vtkProperty.h"#include"vtkCamera.h"#include"vtkLight.h"


// Creamos una esfera representada por polgonos:

vtkSphereSource*sphere=vtkSphereSource::New();sphere->SetThetaResolution(100);sphere->SetPhiResolution(50);

// El mapper es responsable de mapear los datos de entrada a la librera grfica. // Tambin puede mapear colores si se han definido escalares u otros atributos

vtkPolyDataMapper*sphereMapper=vtkPolyDataMapper::New (); sphereMapper->SetInput(sphere->GetOutput());

// El actor dirige la renderizacin de los grficos creados por el mapper. Adems //puede controlar las propiedades y el mapa de textura. En este ejemplo creamos //ocho esferas distintas (dos filas de cuatro esferas) y establecemos los coeficientes //de la luz especular.

vtkActor*sphere1=vtkActor::New();sphere1->SetMapper(sphereMapper);sphere1->GetProperty()->SetColor(1,0,0);sphere1->GetProperty()->SetAmbient(0.3);sphere1->GetProperty()->SetDiffuse(0.0);sphere1->GetProperty()->SetSpecular(1.0);sphere1->GetProperty()->SetSpecularPower(5.0); vtkActor*sphere2=vtkActor::New();sphere2->SetMapper(sphereMapper);sphere2->GetProperty()->SetColor(1,0,0);sphere2->GetProperty()->SetAmbient(0.3);sphere2->GetProperty()->SetDiffuse(0.0);sphere2->GetProperty()->SetSpecular(1.0);sphere2->GetProperty()->SetSpecularPower(10.0);sphere2->AddPosition(1.25,0,0);



vtkActor*sphere3=vtkActor::New();sphere3->SetMapper(sphereMapper);sphere3->GetProperty()->SetColor(1,0,0);sphere3->GetProperty()->SetAmbient(0.3);sphere3->GetProperty()->SetDiffuse(0.0);sphere3->GetProperty()->SetSpecular(1.0);sphere3->GetProperty()->SetSpecularPower(20.0);sphere3->AddPosition(2.5,0,0);

sphere4->SetMapper(sphereMapper);sphere4->GetProperty()->SetColor(1,0,0);sphere4->GetProperty()->SetAmbient(0.3);sphere4->GetProperty()->SetDiffuse(0.0);sphere4->GetProperty()->SetSpecular(1.0);vtkActor*sphere4=vtkActor::New();sphere4->GetProperty()->SetSpecularPower(40.0);sphere4->AddPosition(3.75,0,0);

vtkActor*sphere5=vtkActor::New();sphere5->SetMapper(sphereMapper);sphere5->GetProperty()->SetColor(1,0,0);sphere5->GetProperty()->SetAmbient(0.3);sphere5->GetProperty()->SetDiffuse(0.0);sphere5->GetProperty()->SetSpecular(0.5);sphere5->GetProperty()->SetSpecularPower(5.0);sphere5->AddPosition(0.0,1.25,0);



vtkActor*sphere8=vtkActor::New();



sphere8->SetMapper(sphereMapper);sphere8->GetProperty()->SetColor(1,0,0);sphere8->GetProperty()->SetAmbient(0.3);sphere8->GetProperty()->SetDiffuse(0.0);sphere8->GetProperty()->SetSpecular(0.5);sphere8->GetProperty()->SetSpecularPower(40.0);sphere8->AddPosition(3.75,1.25,0);

// Creamos la estructura grfica. El renderer renderiza en la ventana de //renderizacin. El interactor de la ventana de renderizacin captura las rdenes del //ratn y manipula la cmara y el actor segn dichas rdenes

vtkRenderer*ren1=vtkRenderer::New();vtkRenderWindow*renWin=vtkRenderWindow::New();renWin->AddRenderer(ren1);vtkRenderWindowInteractor*iren=vtkRenderWindowInteractor::New();iren->SetRenderWindow(renWin);

// Aadimos los actores al renderer, seleccionamos el fondo de pantalla y el tamao:

ren1->AddActor(sphere1);ren1->AddActor(sphere2);ren1->AddActor(sphere3);ren1->AddActor(sphere4);ren1->AddActor(sphere5);ren1->AddActor(sphere6);ren1->AddActor(sphere7);ren1->AddActor(sphere8);ren1->SetBackground(0.1,0.2,0.4);renWin->SetSize(400,200);

// Configuramos la iluminacin :

vtkLight*light=vtkLight::New();light->SetFocalPoint(1.875,0.6125,0);light->SetPosition(0.875,1.6125,1);ren1->AddLight(light);

// Queremos eliminar los efectos de la perspectiva en la iluminacin. // Usamos una proyeccin de cmara paralela. Para usar el zoom en el modo de //proyeccin paralela configuramos el ParallelScale:

ren1->GetActiveCamera()->SetFocalPoint(0,0,0);ren1->GetActiveCamera()->SetPosition(0,0,1);ren1->GetActiveCamera()->SetViewUp(0,1,0);ren1->GetActiveCamera()->ParallelProjectionOn();



ren1->ResetCamera();ren1->GetActiveCamera()->SetParallelScale(1.5);

// Inicializamos la opcin de giro y comenzamos la renderizacin:

iren->Initialize();iren->Start();

// Para finalizar, borramos todos los objetos creados:

sphere->Delete();sphereMapper->Delete();sphere1->Delete();sphere2->Delete();sphere3->Delete();sphere4->Delete();sphere5->Delete();sphere6->Delete();sphere7->Delete();sphere8->Delete();ren1->Delete();renWin->Delete();iren->Delete();

return0;}

/**************************************************************************************/ El fichero CMakeLists.txt necesario para la ejecucin de CMake ser el siguiente:

PROJECT (SpecularSpheres) INCLUDE (${CMAKE_ROOT}/Modules/FindVTK.cmake) IF (USE_VTK_FILE) INCLUDE(${USE_VTK_FILE}) ENDIF (USE_VTK_FILE)

ADD_EXECUTABLE(SpecularSpheres SpecularSpheres.cxx) TARGET_LINK_LIBRARIES(SpecularSpheres vtkRendering)



Una vez CMake ha generado los ficheros necesarios, el resultado de la ejecucin

del programa ser la siguiente ventana ( las esferas podrn girarse en conjunto moviendo el ratn mientras se mantiene el botn izquierdo pulsado):

Figura 3.8: Manipulacin de luces


4 Fasesdelareconstruccin3D

La base de la visualizacin de datos est en el uso de algoritmos que transformen estos datos. Existen varios tipos de algoritmos, que se pueden clasificar dependiendo de la estructura y del tipo de transformacin. Por estructura entendemos los efectos que la transformacin tiene en la topologa y geometra del dataset. Y por tipo, el tipo de dataset sobre el que operan los algoritmos. Dependiendo de la estructura tenemos los siguientes algoritmos: transformaciones geomtricas, topolgicas, de atributos, o combinaciones. Dependiendo del tipo de datos sobre los que operan tenemos: algoritmos escalares, vectoriales, tensores o de modelado. Nosotros vamos a tratar los algoritmos escalares. Y en particular, nos centraremos en la tcnica de contorneado. Cuando vemos una superficie coloreada con valores de datos, el ojo a menudo separa las reas de colores similares en distintas regiones. Cuando contorneamos los datos, estamos construyendo los lmites entre esas regiones. Estos lmites corresponden a lneas de contorno (en 2D) y superficies (en 3D) de valores escalares

Fases de la reconstruccin 3D Ignacio Berzal Moreno


constantes. Los contornos tridimensionales se llaman isosuperficies, como por ejemplo las superficies de presin y temperatura constante de un fluido.

4.1 Conversindeldominiodeadquisicinalmallad o(marchingcubes)

Considerando una estructura de mallado, cada punto que define la malla tiene asociado un valor escalar. El contorneado siempre comienza por seleccionar un valor escalar, o valor de contorno, que se corresponda con la lnea o superficie de contorno generada. Para generar los contornos debe usarse alguna forma de interpolacin. Esto se debe a que tenemos valores escalares en un conjunto finito de puntos en el dataset, y nuestro valor de contorno puede estar entre los valores de los puntos. La tcnica de interpolacin ms comn es la lineal; generamos puntos en la superficie de contorno por interpolacin lineal a lo largo de las aristas.

Figura 4.1: Contorneo de una malla 2D estructurada con valor lnea de contorno de valor 5.

Una vez los puntos extremos de las celdas son generados, podemos conectar estos puntos para crear contornos usando diferentes tcnicas. Una de ellas acta de la siguiente manera: detecta una interseccin de arista ( por ejemplo, el contorno pasa a travs de una arista ) y entonces rastrea ese contorno movindose a lo largo de los lmites de la celda. Sabemos que si el extremo de un contorno entra en una celda, debe salir de la misma. El contorno es rastreado hasta que se cierra sobre s mismo, o abandona los lmites del dataset. Si es sabido que slo existe un contorno simple, el

Ignacio Berzal Moreno Fases de la reconstruccin 3D


proceso finaliza. De otra manera, todos los extremos en el dataset deben ser comprobados para asegurar si existen otras lneas de contorno. Otra tcnica es la llamada Marching Squares ,en 2D, o Marching Cubes, en 3D, que trata las celdas independientemente. La suposicin bsica de esta tcnica es la de que un contorno slo puede atravesar una celda de un nmero finito de maneras. Se elabora una tabla de casos, que enumera todos los estados topolgicos posibles de una celda, dadas las combinaciones de valores escalares en los puntos de la celda. El nmero de estados topolgicos depende del nmero de vrtices de la celda, y del nmero de relaciones de entrada/salida que puede tener cada vrtice con respecto a los valores de contorno. Se considera que un vrtice se encuentra dentro de un contorno si su valor escalar es mayor que el valor escalar de la lnea de contorno. Los vrtices con valor escalar menor que el valor de contorno se consideran fuera del contorno. Por ejemplo, si una celda tiene cuatro vrtices, y cada vrtice puede estar dentro o fuera del contorno, existen 2 4 = 16 maneras posibles de que el contorno atraviese la celda. En la tabla de casos no nos interesa por que punto atraviesa el contorno a la celda, sino la manera en que lo hace. La siguiente figura muestra las 16 combinaciones posibles en una celda cuadrada. Los vrtices en negro indican que el valor escalar est por encima del de contorno:

Figura 4.2: Combinaciones posibles en que un contorno atraviesa una celda cuadrada

En 3 dimensiones, para una celda cbica, existen 256 combinaciones

diferentes de valores escalares dadas por los estados de los 8 distintos vrtices de un cubo (2 8 = 256 ). La figura 4.3 muestra estas combinaciones, que se pueden reducir a 15 casos, usando argumentos de simetra. Podemos usar combinaciones de rotaciones y simetras para producir casos topolgicamente independientes.

Los ndices de la tabla de casos pueden ser computados codificando el estado de cada vrtice como un dgito binario. Para la representacin de datos 2D en un malla rectangular, podemos representar los 16 casos con ndices de 4 bits; en 3D, con un mallado cbico, necesitaremos 8 bits para representar los 256 casos posibles. Una



vez el caso particular es seleccionado, la localizacin de la interseccin entre la lnea de contorno y la arista de la celda puede ser calculado por interpolacin. El algoritmo procesa una celda, y luego pasa a la siguiente. El contorno estar completo despus de que todas las celdas sean procesadas.

Figura 4.3: Combinaciones posibles en que un contorno atraviesa una celda cbica

En resumen, los algoritmos de marching squares y marching cubes siguen los siguientes pasos:

1- Seleccin de una celda. 2- Clculo del estado interior o exterior de cada vrtice de la celda.

3- Creacin de un ndice que almacena el estado binario de cada vrtice en un

bit separado. 4- Uso del ndice para buscar el estado topolgico de la celda en una tabla de

casos.

5- Clculo de la localizacin del contorno (por interpolacin) para cada arista en la tabla de casos.



4.2Reduccindepuntosdemallado

Los procedimientos de marching squares y marching cubes construyen primitivas geomtricas independientes en cada celda. En los lmites de las celdas pueden crearse vrtices y aristas duplicados. Estos duplicados pueden ser eliminados empleando una operacin especial de fusin de puntos coincidentes. Hay que tener en cuenta que la interpolacin a lo largo de cada arista debe realizarse siempre en la misma direccin. Si esto no se cumple, pueden generarse puntos que no coincidan exactamente, debido al redondeado numrico, y no sern fusionados correctamente. Existen ventajas y desventajas entre la tcnica del rastreo de aristas y la de marching cubes. El algoritmo de marching squares es fcil de implementar. Esto es particularmente importante cuando aplicamos la tcnica en tres dimensiones, donde el rastreo de isosuperficies se torna mucho ms complicado. Por otra parte, el algoritmo crea puntos y segmentos desconectados, y la operacin de fusionado necesaria requiere recursos de computacin extras. El algoritmo de rastreo puede ser implementado para generar una polilnea simple por lnea de contorno, evitndose la necesidad de fusionar los puntos coincidentes.

4.3Suavizadodelmallado

Con el uso de estas tcnicas se nos plantea el problema de la ambigedad de contorneo. Al estudiar con detenimiento algunas de las combinaciones posibles de celdas de marching squares (casos 5 y 10), y marching cubes (casos 3, 6, 7, 10, 12, 13), podemos observar que pueden ser contorneadas de ms de una forma. La ambigedad de contorneo aparece en las celdas cuadradas en 2D, o en las caras de las celdas cbicas en 3D, cuando los vrtices de una misma arista tienen estados distintos, pero sus opuestos diagonalmente poseen estados idnticos. La ambigedad de contorneo puede tratarse de manera simple en 2D: para cada caso ambiguo implementamos una de las dos posibles soluciones. Para cada caso particular la eleccin se lleva a cabo de manera independiente. Dependiendo de la eleccin, el contorneo prolongar o cortar el contorno en proceso de formacin, como se muestra en la siguiente figura:

Figura 4.4: Ambigedad de contorneo



Cualquier eleccin es aceptable mientras que la lnea de contorno resultante sea continua y cerrada (o termine en los lmites del dataset). El problema es ms complejo en tres dimensiones. Ahora no podemos elegir uno de los casos ambiguos sin tener en cuenta todos los dems. En la siguiente figura podemos apreciar lo que puede ocurrir si implementamos dos casos ambiguos independientemente uno del otro:

Figura 4.5: Implementacin de dos casos ambiguos de manera independiente

Tenemos el caso de celda cbica 3 y un caso complementario del 6, el 6c, en los que se ha elegido uno de los casos ambiguos, Al conectar los dos cubos observamos que aparece una zona hueca en la isosuperficie. Se han desarrollado distintas tcnicas para solventar este problema: - Marching tetrahedra: Esta tcnica consiste en descomponer las celdas cbicas en tetraedros. Al hacer esto, los casos ambiguos desaparecen. Las desventajas son que el algoritmo de marching tetrahedra genera isosuperficies formadas por ms tringulos, y que la descomposicin de un cubo en tetraedros requiere hacer una eleccin con respecto a la orientacin de los mismos. Esta eleccin puede resultar en la aparicin de "protuberancias" artificiales en la isosuperficie debido a la interpolacin a lo largo de las diagonales de cara, como muestra la siguiente figura:



Figura 4.6: Marching tetrahedra

- Asymptotic decider: Esta tcnica, desarrollada por Nielson y Hamann, consiste en evaluar el comportamiento asinttico de la superficie, y decidir despus los casos en los que unir o romper el contorno. Se basa en el anlisis de la variacin de la variable escalar a lo largo de una cara ambigua. El anlisis determina cmo deben ser conectados los bordes de los polgonos de la isosuperficie. - Casos complementarios: sta es una tcnica simple pero efectiva, consistente en aadir casos adicionales complementarios a los 15 casos originales de marching cubes. Estos casos son diseados para ser compatibles con los casos cercanos y prevenir la aparicin de "huecos" en la isosuperficie. Se necesitan seis casos complementarios, que se corresponden con los casos originales 3, 6, 7, 10, 12 y 13, como se puede apreciar en la figura:

Figura 4.7: Casos complementarios de marching cubes



La tcnica general de marching squares y marching cubes puede extenderse a otros tipos topolgicos. En VTK se emplean marching lines, marching triangles y marching tetrahedra para contorneo de celdas de esos mismos tipos (lneas, tringulos y tetraedros), o celdas compuestas por combinaciones de los mismos. Adems, aunque hablamos de tipos de celdas regulares, como cuadrados y cubos, el algoritmo de marching cubes puede aplicarse a cualquier tipo de celda topolgicamente equivalente a un cubo.


5 Aplicaciones sobre una piladeimgenesdelconfocal

Podemos crear imgenes de cuerpos tridimensionales a partir de imgenes bidimensionales de cortes transversales obtenidas mediante un microscopio confocal. Esto nos sirve para sintetizar imgenes mostrando atributos que no son visibles aparentemente en las imgenes originales por separado, como la profundidad. Es el caso de imgenes biomdicas, por ejemplo en las que hay superposicin de intensidades y texturas cuando vemos una imagen de resonancia magntica. Para resolver este problema aplicamos un mtodo llamado segmentacin, mediante el cual identificamos las diferentes superficies que componen el cuerpo de nuestra imagen.

Para nuestro propsito debemos de tener identificado cada pxel en cada corte de

un volumen de datos con un identificador de superficie. Este identificador es un nmero entero que describe la clase de superficie a la que pertenece cada pxel.

Debemos desarrollar una estrategia para poder crear un programa que extraiga las

diferentes superficies que compongan el cuerpo y poder visualizarlas por separado o conjuntamente. En el caso de tener un elevado nmero de superficies, tendremos que operar con un elevado nmero de parmetros y de filtros de imgenes. Nuestro objetivo ser desarrollar un pipeline general que nos servir para todos los casos.

Aplicaciones sobre una pila de imagen del confocal Ignacio Berzal Moreno


Tambin debemos designar el programa en el que trabajaremos con un conjunto de parmetros de uso especfico para el control de los elementos del pipeline. Trabajando en C++, debemos designar el formato del fichero y escribir el cdigo para interpretar las declaraciones. La forma de generar modelos ser la siguiente. Primero ejecutamos un fichero de VTK para cada superficie. Este fichero generar un fichero .vtk que contendr la representacin poligonal de cada superficie. Despus renderizaremos los modelos por separado. 5.1Desarrollodelpipeline

Es necesaria la construccin de un pipeline genrico que podamos utilizar para diferentes casos de construccin de modelos en los que nos encontremos con un nmero diferente, en algunos casos elevado, de superficies o tejidos. En la siguiente figura se muestra un pipeline genrico que puede ser empleado para este fin. Este pipeline genera modelos razonables de dataset segmentados. El volumen pasa a travs del pipeline antes de la extraccin de la isosuperficie.

Figura 5.1: pipeline genrico

Ignacio Berzal Moreno Aplicaciones sobre una pila de imagen del confocal


5.2Leerlosdatosdelapiladeimagen

Debemos suponer que todas las imgenes que van a ser procesadas son adquiridas fijando una marca central constante. En VTK, el origen de los datos se aplica en la parte izquierda inferior de la imagen. El centro x,y del volumen ser el punto (0,0). La clase DataSpacing describe el valor de cada pxel y la distancia entre los cortes. La clase DataVOI selecciona un volumen de inters, esto es, selecciona las reas de inters, eliminando estructuras extraas si es necesario.

El mtodo SetTransform() define como disponer el dato en memoria. Este filtro transforma los vrtices de los tringulos de modo que los modelos resultantes se podrn ver todos de frente, y con una vista respecto a la posicin de los ejes de (0,-1,0). La correspondencia derecha-izquierda ser mantenida. Esto significa que la izquierda del cuerpo siempre ser la izquierda del modelo generado.

El pipeline solo ser ejecutado una vez. Para conservar memoria, invocamos el mtodo ReleaseDataFlagOn(). ste permite que el pipeline libere datos una vez que han sido procesados por un filtro. En dataset de imgenes mdicas de gran tamao, esto puede ser la diferencia entre poder llevar a cabo el procesamiento de un dataset o no. originx=((COLUMNS/2.0)*PXEL_SIZE*-1.0);originy=((ROWS/2.0)*PXEL_SIZE*-1.0);vtkPNMReader*reader=vtkPNMReader::New(); reader->SetFilePrefix(STUDY); reader->SetDataSpacing(PIXEL_SIZE,PIXEL_SIZE,SPA CING); reader->SetDataOrigin(originx,originy);START_SLICE*SLICE_ORDER reader->SetDataVOI(VOI); reader->SetTransform(SLICE_ORDER); reader->GetOutput()->ReleaseDataFlagOn();

Aplicaciones sobre una pila de imagen del confocal Ignacio Berzal Moreno


Figura 5.2: Diagrama de herencia de la clase vtkPNMReader 5.3Trasladarislas

Algunas tcnicas de segmentacin pueden generar islas de vxeles sin clasificar. Un vxel es un pequeo elemento de volumen, se puede definir como una celda primaria tridimensional con seis caras. Este filtro conecta pxeles con la etiqueta ISLAND_REPLACE, y si el nmero de pxeles es menor que ISLAND_AREA, los reemplaza por la etiqueta TISSUE. Este filtro solo es ejecutado si ISLAND_REPLACE es positivo.

Ignacio Berzal Moreno Aplicaciones sobre una pila de imagen del confocal


lastConnection=reader;if{ISLAND_REPLACE>=0}{ vtkImageIslandRemoval2D*islandRemover=vtkImageIslandRemoval2D::New(); islandRemover->SetAreaThreshold(ISLAND_AREA); islandRemover->SetIslandValue(ISLAND_REPLACE); islandRemover->SetReplaceValue

vision por computadora procesamiento de imagenes con vtk pfc_i_berzal.pdf

Documents