PFC I Berzal

Desarrollo de algoritmos de procesamiento de imgenes con VTK
Autor: Ignacio Berzal Moreno Tutor: Carlos Platero Dueas
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.
ndice
1 2
Introduccin ...........................1
1.1 Objetivos ...............................................................................2 1.2 Sumario del proyecto ...........................................................3
Estado de la tcnica................5
2.1 Herramientas de visualizacin de imgenes ......................5

2.1.1 Matlab .........................................................................................5 2.1.1.1 Procesado de imgenes con MATLAB ..........................7 2.1.2 SDC .............................................................................................7 2.1.3 VTK .............................................................................................8 2.1.3.1 Visualizacin con VTK ..................................................9 2.1.4 ParaView .....................................................................................9 2.1.5 ITK .............................................................................................11 2.1.6 OpenMoxis ................................................................................12 2.1.7 MPI ............................................................................................13
GVA-ELAI-UPMPFC0081-2004
Funcionamiento de VTK ........15
3.1 Instalacin de VTK...............................................................16

3.1.1 Instalacin binaria ....................................................................16 3.1.2 Instalacin del cdigo fuente . .................................................17
3.2 Funcionamiento en C++ de VTK.........................................17

3.2.1 CMake .....................................................................................17 3.2.2 Arquitectura de VTK.................................................................18 3.2.2.1 Graphics model ...........................................................19 3.2.2.2 Visualization model ......................................................20 3.2.2.2.1 Ejecucin del pipeline.....................................23 3.2.2.2.2 Procesamiento de la imagen..........................24 3.2.3 Creacin de una aplicacin .......................................................24
3.3 Ejemplos...............................................................................25
3.3.1 Renderizacin de un cilindro......................................................25 3.3.2 Renderizacin de un cono.........................................................27 3.3.3 Manipulacin de luces................................................................30
Fases de la reconstruccin
3D.................................................... 37
4.1 Conversin del dominio de adquisicin al mallado (marching cubes).......................................................................38 4.2 Reduccin de puntos de mallado ......................................40
4.3 Suavizado del mallado ........................................................41
Aplicaciones sobre una pila
de imgenes del confocal ............45

5.1 Desarrollo del pipeline.........................................................46 5.2 Leer los datos de la pila de imagen ...................................47 5.3 Trasladar islas .....................................................................48 5.4 Seleccionar una superficie .................................................50 5.5 Remuestreo de volumen ....................................................52 5.6 Alisar los datos de volumen ..............................................53 5.7 Generar tringulos ..............................................................55 5.8 Reducir el nmero de tringulos .......................................55 5.9 Alisar vrtices de tringulos ..............................................57 5.10 Generar ejemplares ...........................................................58 5.11 Generar strips de tringulos ............................................60 5.12 Escribir tringulos a un fichero .......................................60 5.13 Ejecutar el pipeline ...........................................................61 5.14 Especificar parmetros para el pipeline .........................61 5.15 Ejemplo...............................................................................62
Combinacin de la difusin
isotrpica y anisotrpica en el procesamiento de imgenes ........69

6.1 Introduccin al filtrado de difusin ...................................69 6.2 Difusin anisotrpica de realce de la coherencia local...71 6.3 Condiciones de difusin anisotrpica e isotrpica de CED .....................................................................................................75 6.4 Combinacin de la difusin isotrpica y anisotrpica ....76
6.4.1 Resultados de difusin isotrpica y anisotrpica. Ejemplos............................................................................................77
Aplicacin del filtrado de
difusin con imgenes JPG y PIC .........................................................83

7.1 Modelado UML ....................................................................83
7.1.1 Introduccin ...............................................................................83 7.1.2 Modelado visual ........................................................................85 7.1.3 Qu es UML? ..........................................................................85 7.1.4 Diagramas UML ........................................................................86 7.1.5 Proceso de desarrollo ...............................................................89
7.2 La herramienta Rational Rose ...........................................91 7.3 Documentacin de la aplicacin difusin2D3D ...............91
7.3.1 Visin y alcance de la aplicacin...............................................92 7.3.1.1 Requerimientos del negocio ........................................92 7.3.1.1.1 Introduccin ............................................... ...92 7.3.1.1.2 Oportunidad del negocio.................................93 7.3.1.1.3 Objetivos esenciales y criterios de xito ........93 7.3.1.1.4 Necesidades de los usuarios .........................93 7.3.1.1.5 Riesgos del negocio ......................................94 7.3.1.2 Visin de la solucin ....................................................94 7.3.1.2.1 Visin global ...................................................94 7.3.1.2.2 Principales caractersticas .............................95 7.3.1.2.3 Suposiciones y dependencias.......................95 7.3.1.3 Alcance y restricciones ................................................96 7.3.1.3.1 Caractersticas principales en la primera versin ..........................................................................96 7.3.1.3.2 Mejoras en las siguientes versiones ..............96 7.3.1.3.3 Limitaciones y Exclusiones ............................97 7.3.2 Casos de uso ............................................................................97 7.3.2.1 Caso de uso visualizar 2D ........................................97
7.3.2.1.1 Actor ...............................................................97 7.3.2.1.2 Descripcin ....................................................98 7.3.2.1.3 Precondiciones .............................................98 7.3.2.1.4 Poscondiciones .............................................98 7.3.2.1.5 Curso de xito ...............................................98 7.3.2.1.6 Curso alternativo ..........................................99 7.3.2.1.7 Excepciones .................................................99 7.3.2.1.8 Prioridad .......................................................99 7.3.2.1.9 Frecuencia de caso de uso ...........................99
7.3.2.1.10 Requerimientos especiales ......................100 7.3.2.1.11 Suposiciones de partida ..........................100 7.3.2.1.12 Cuadro resumen del caso de uso visualizar
2D ...............................................................................100 7.3.2.2 Caso de uso visualizar 3D ......................................101
7.3.2.2.1 Actor .............................................................101 7.3.2.2.2 Descripcin ..................................................101 7.3.2.2.3 Precondiciones ...........................................101 7.3.2.2.4 Poscondiciones ...........................................101 7.3.2.2.5 Curso de xito ..............................................102 7.3.2.2.6 Curso alternativo ........................................102 7.3.2.2.7 Excepciones ...............................................102 7.3.2.2.8 Prioridad .....................................................103 7.3.2.2.9 Frecuencia de caso de uso .........................103 7.3.2.2.10 Requerimientos especiales ......................103 7.3.2.2.11 Suposiciones de partida ..........................103 7.3.2.2.12 Cuadro resumen del caso de uso visualizar
3D ...............................................................................104 7.3.2.3 Caso de uso filtrar difusin 2D ...............................104
7.3.2.3.1 Actor ............................................................104 7.3.2.3.2 Descripcin ..................................................105 7.3.2.3.3 Precondiciones ...........................................105 7.3.2.3.4 Poscondiciones ...........................................105 7.3.2.3.5 Curso de xito ..............................................105 7.3.2.3.6 Curso alternativo ........................................106 7.3.2.3.7 Excepciones ...............................................106 7.3.2.3.8 Prioridad .....................................................106 7.3.2.3.9 Frecuencia de caso de uso .........................107
7.3.2.3.10 Requerimientos especiales ......................107 7.3.2.3.11 Suposiciones de partida ..........................107 7.3.2.3.12 Cuadro resumen del caso de uso filtrar
difusin 2D...................................................................107 7.3.2.4 Caso de uso filtrar difusin 3D ...............................108
7.3.2.4.1 Actor .............................................................108 7.3.2.4.2 Descripcin ..................................................108 7.3.2.4.3 Precondiciones ...........................................109 7.3.2.4.4 Poscondiciones ...........................................109 7.3.2.4.5 Curso de xito ..............................................109 7.3.2.4.6 Curso alternativo ........................................109 7.3.2.4.7 Excepciones ...............................................110 7.3.2.4.8 Prioridad .....................................................110 7.3.2.4.9 Frecuencia de caso de uso .........................110 7.3.2.4.10 Requerimientos especiales ......................111 7.3.2.4.11 Suposiciones de partida ..........................111 7.3.2.4.12 Cuadro resumen del caso de uso filtrar
difusin 3D ..................................................................111
7.4 Creacin de la aplicacin mediante Rational Rose .......112

7.4.1 Creacin del proyecto .............................................................112 7.4.2 Creacin de casos de uso ......................................................113 7.4.3 Creacin del diagrama de clases del modelo de anlisis ......114 7.4.4 Creacin del diagrama de secuencia ......................................115 7.4.5 Creacin del diagrama de clases del diseo ..........................116 7.4.6 Generacin de cdigo mediante Rational Rose ......................117 7.4.7 Ingeniera inversa ....................................................................121 7.4.7.1 Configuracin de Rational Rose: Visual C++ Add-in..122 7.4.7.2 Ingeniera inversa con una aplicacin .......................124
7.5 Implementacin del cdigo ..............................................128

7.5.1 Descripcin de las clases empleadas en la aplicacin ...........129
7.5.1.1 Clase visualizacin2D ...............................................129 7.5.1.2 Clase visualizacin3D ...............................................132 7.5.1.3 Clase filtradoDifusin2D ............................................138 7.5.1.4 Clase filtradoDifusin3D ............................................143 7.5.1.5 Clase vistaFiltradoDifusin2D3D ...............................150 7.5.2 Fichero principal de la aplicacin ............................................155 7.5.3 Archivo CMakeLists ................................................................156
8 9
Conclusiones ......................157
8.1 Principales aportaciones ..................................................157 8.2 Futuras mejoras ................................................................158
Bibliografa .........................161
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.
GVA-ELAI-UPMPFC0081-2004 1
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.
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
Sumario del proyecto
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
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.
Estado de la tcnica
2.1 Herramientas de visualizacin de imgenes

Existen distintas herramientas para la visualizacin de imgenes mediante un soporte informtico. En este captulo trataremos con brevedad algunas de ellas.
2.1.1 Matlab 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.
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
2.1.1.1 Procesado de imgenes con MATLAB 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.2 SDC 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.3 VTK 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
Visualizacin con VTK
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
10
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.
11
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
12
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
13
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
14
Funcionamiento de VTK
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.
15
Ignacio Berzal Moreno
3.1 Instalacin de VTK

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.1 Instalacin binaria 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
16
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 Instalacin del cdigo fuente 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 Funcionamiento en C++ de VTK
3.2.1 CMake 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.2 Arquitectura de VTK 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.
18
3.2.2.1 Graphics model 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.
19
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.2 Visualization model 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.
20
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:
21
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:
22
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.1 Ejecucin del 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.
23
3.2.2.2.2 Procesamiento de la imagen 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.3 Creacin de una aplicacin 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.
24
3.3 Ejemplos
3.3.1 Renderizacin de un cilindro 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: int main(int argc, 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::New(); 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);
25
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(); return 0; } /*******************************************************************/ 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:
26
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.2 Renderizacin de un cono 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: int main( int argc, char *argv[] ) { // 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
28 GVA-ELAI-UPMPFC0081-2004
// 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: int i; for (i = 0; i < 360; ++i) { // Renderizacin de la imagen: renWin->Render(); // 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(); return 0; } /*******************************************************************/ 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.3 Manipulacin de luces 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" int main(int argc, char *argv[]) { // 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 *sphere6 = vtkActor::New(); sphere6->SetMapper(sphereMapper); sphere6->GetProperty()->SetColor(1,0,0); sphere6->GetProperty()->SetAmbient(0.3); sphere6->GetProperty()->SetDiffuse(0.0); sphere6->GetProperty()->SetSpecular(0.5); sphere6->GetProperty()->SetSpecularPower(10.0); sphere6->AddPosition(1.25,1.25,0); vtkActor *sphere7 = vtkActor::New(); sphere7->SetMapper(sphereMapper); sphere7->GetProperty()->SetColor(1,0,0); sphere7->GetProperty()->SetAmbient(0.3); sphere7->GetProperty()->SetDiffuse(0.0); sphere7->GetProperty()->SetSpecular(0.5); sphere7->GetProperty()->SetSpecularPower(20.0); sphere7->AddPosition(2.5,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(); return 0; } /**************************************************************************************/
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)
34
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
35
36
Fases de la reconstruccin 3D
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
37
constantes. Los contornos tridimensionales se llaman isosuperficies, como por ejemplo las superficies de presin y temperatura constante de un fluido.
4.1
Conversin del dominio de adquisicin al mallado (marching cubes)
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
proceso finaliza. De otra manera, todos los extremos en el dataset comprobados para asegurar si existen otras lneas de contorno.
deben ser
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.
40
4.2 Reduccin de puntos de mallado

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.3 Suavizado del mallado

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:
42
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
43
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.
44
Aplicaciones sobre una pila
de imgenes del confocal

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
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.1 Desarrollo del pipeline

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
46
5.2 Leer los datos de la pila de imagen

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, SPACING); reader-> SetDataOrigin(originx, originy); START_SLICE * SLICE_ORDER reader-> SetDataVOI(VOI); reader-> SetTransform(SLICE_ORDER); reader-> GetOutput()-> ReleaseDataFlagOn();
47
Figura 5.2: Diagrama de herencia de la clase vtkPNMReader
5.3 Trasladar islas

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.
48
lastConnection = reader; if { ISLAND_REPLACE >=0 } {

vtkImageIslandRemoval2D*islandRemover= vtkImageIslandRemoval2D::New();
islandRemover-> SetAreaThreshold(ISLAND_AREA); islandRemover-> SetIslandValue(ISLAND_REPLACE); islandRemover-> SetReplaceValue(TISSUE); islandRemover-> SetInput( lastConnection-> GetOutput()); lastConnection = islandRemover; }
Figura 5.3: Diagrama de colaboracin de la clase vtkImageIslandRemoval2D
49
Figura 5.4: Diagrama de herencia de la clase vtkImageIslandRemoval2D
5.4 Seleccionar una superficie

El resto del pipeline requiere datos en escala de grises. Para convertir el volumen que contiene todas las etiquetas de las superficies a un volumen de escala de gris que contenga solo una superficie, usamos el filtro threshold para colocar todos los pxeles con el valor TISSUE a 255 y todos los otros pxeles a 0. La eleccin de 255 es arbitraria.
vtkImageThreshold *selectTissue = vtkImageThreshold::New(); selectTissue-> ThresholdBetween(TISSUE, TISSUE); selectTissue-> SetInValue(255); selectTissue-> SetOutValue(0); selectTissue-> SetInput(lastConnection-> GetOutput());
50
Figura 5.5: Diagrama de herencia de la clase vtkImageThreshold
Figura 5.6: Diagrama de colaboracin de la clase vtkImageThreshold

5.5 Remuestreo de volumen

Reducir la resolucin de volmenes produce menos polgonos. Por experimentacin, a menudo reducimos la resolucin del dato con este filtro. Sin embargo, los detalles pueden perderse durante el proceso. Se pueden crear nuevos pxeles en el volumen remuestreado mediante un promedio de los pxeles vecinos. Si el promedio es desactivado, cada pxel SAMPLE_RATE ser llevado a la salida.
vtkImageShrink3D *shrinker = vtkImageShrink3D::New(); shrinker-> SetInput(selectTissue-> GetOutput()); shrinker-> SetShrinkFactors(SAMPLE_RATE); shrinker-> AveragingOn();
Figura 5.7: Diagrama de herencia de la clase vtkImageShrink3D
52
Figura 5.7: Diagrama de colaboracin de la clase vtkImageShrink3D
5.6 Alisar los datos de volumen

En este punto, el volumen es etiquetado con un valor de 255 en los pxeles de la superficie seleccionada y 0 en cualquier otra. Este volumen binario producira superficies rugosas si no lo difuminamos. El ncleo Gaussiano especificado en este filtro lleva a cabo el alisado que nosotros requerimos para extraer superficies. El nivel de alisado es controlado por GAUSSIAN_STANDARD_DEVIATION que puede ser especificado independientemente por cada eje del dato de volumen. Slo ejecutaremos este filtro si se requiere algn tipo de alisado. lastConnection = shrinker; if {GAUSSIAN_STANDARD_DEVIATION = 0 0 0} { vtkImageGaussianSmooth *gaussian = vtkImageGaussianSmooth::New(); gaussian-> SetDimensionality(3); gaussian-> SetStandardDeviation(GAUSSIAN_STANDARD_DEVIATION); gaussian-> SetRadiusFactor(1); lastConnection = gaussian;}
Figura 5.8: Diagrama de herencia de la clase vtkImageGaussianSmooth
Figura 5.9: Diagrama de colaboracin de la clase vtkImageGaussianSmooth

5.7 Generar tringulos

Podemos procesar el volumen con el mtodo marching cubes como si hubiramos obtenido un dato en escala de grises mediante un escner. El filtro se ejecuta ms rpido si desactivamos el gradiente y los clculos normales. El marching cubes normalmente calcula puntos normales a partir del gradiente del dato de volumen. En nuestro pipeline hemos confeccionado una representacin en escala de grises y seguidamente diezmaremos la malla del tringulo y alisaremos los vrtices resultantes. Este proceso invalida los normales que son calculados por marching cubes. vtkMarchingCubes *mcubes = vtkMarchingCubes::New(); mcubes-> SetInput(toStructuredPoints-> GetOutput()); mcubes-> ComputeScalarsOff(); mcubes-> ComputeGradientsOff(); mcubes-> ComputeNormalsOff(); mcubes-> SetValue(0, VALUE); mcubes-> GetOutput(ReleaseDataFlagOn);
Figura 5.10: Diagrama de herencia de la clase vtkMarchingCubes
5.8 Reducir el nmero de tringulos

A menudo hay muchos ms tringulos generados por el algoritmo de isosuperfcie de los que necesitamos para la renderizacin. Aqu reducimos la
cantidad de tringulos, eliminando los vrtices de los tringulos que se encuentran dentro de una distancia especificada por el usuario al plano formado por los vrtices cercanos. Preservamos algunas esquinas de tringulos que son consideradas distintivas.
vtkDecimate *decimator = vtkDecimate::New(); decimator-> SetInput(mcubes-> GetOutput()); decimator-> SetInitialFeatureAngle(DECIMATE_ANGLE); decimator-> SetMaximumIterations(DECIMATE_ITERATIONS); decimator-> SetMaximumIterations(0); decimator-> PreserveEdgesOn(); decimator-> SetMaximuError(1); decimator-> SetTargetReduction(DECIMATE_REDUCTION); decimator-> SetInitialError(DECIMATE_ERROR); decimator-> SetErrorIncrement(DECIMATE_ERROR_INCREMENT); decimator-> GetOutput(ReleaseDataFlagOn);
Figura 5.11: Diagrama de herencia de la clase vtkDecimate
56
Figura 5.12: Diagrama de colaboracin de la clase vtkDecimate
5.9 Alisar vrtices de tringulos

Este filtro usa un Laplaciano para ajustar vrtices de tringulos como un promedio de extremos de vrtices. El mecanismo ser menor que un vxel. Nosotros tenemos que alisar el dato de imagen con un ncleo Gaussiano as que esto no dar mucha perfeccin, sin embargo, los modelos que son diezmados en gran cantidad pueden ser algunas veces perfeccionados con un alisado poligonal adicional.
vtkSmoothPolyDataFilter *smoother = vtkSmoothPolyDataFilter::New(); smoother-> SetInput(decimator-> GetOutput()); smoother-> SetNumberOfIterations(SMOOTH_ITERATIONS); smoother-> SetRelaxationFactor(SMOOTH_FACTOR); smoother-> SetFeatureAngle(SMOOTH_ANGLE); smoother-> BoundarySmoothingOff(); smoother-> SetConvergence(0); smoother-> GetOutput(ReleaseDataFlagOn);
57
Figura 5.13: Diagrama de herencia de la clase vtkSmoothPolyDataFilter
5.10 Generar ejemplares

Para generar modelos sombreados alisados durante la renderizacin, necesitamos ejemplares de cada vertex. Se pueden remarcar las esquinas ajustando el ngulo distintivo.
vtkPolyDataNormals *normals = vtkPolyDataNormals::New(); normals-> SetInput(smoother-> GetOutput()); normals-> SetFeatureAngle(REATURE_ANGLE); normals-> GetOutput(ReleaseDataFlagOn);
58
Figura 5.14: Diagrama de herencia de la clase vtkPolyDataNormals
Figura 5.15: Diagrama de colaboracin de la clase vtkPolyDataNormals
59
5.11 Generar strips de tringulos

Los strips de tringulos son una representacin compacta de un gran nmero de tringulos. Este filtro procesa nuestros tringulos independientes antes de que los escribamos a un fichero. VtkStripper *stripper = vtkStripper::New(); stripper-> SetInput(normals-> GetOutput()); stripper-> GetOutput(ReleaseDAtaFlagOn());
Figura 5.16: Diagrama de herencia de la clase vtkStripper
5.12 Escribir tringulos en un fichero

Finalmente, el ltimo componente del pipeline es escribir strips de tringulos en un fichero. vtkPolyDataWriter *writer = vtkPolyDataWriter::New(); writer-> SetInput(stripper-> GetOutput()); writer-> SetFileName(NAME.vtk);
60
Figura 5.17: Diagrama de herencia de la clase vtkPolyDataWriter
5.13 Ejecutar el pipeline

VTK usa una arquitectura pipeline para conducir la peticin, pero de momento no ha habido ninguna. Hasta ahora hemos especificado la topologa del pipeline y los parmetros para cada elemento. writer Update; Esto hace que se ejecute el pipeline.
5.14 Especificar parmetros para el pipeline

Todas las variables mencionadas anteriormente deben ser definidas para cada superficie que vaya a ser procesada. Los parmetros se dividen en dos categoras generales. Algunas son especificadas para cada estudio particular mientras que otras son especificada para cada superficie.
61
Hay un fichero especfico para cada tipo de superficie. Este fichero especfico lee en el fichero donde estn especificados los parmetros, obtiene estos parmetros y lee el pipeline. Una vez que los modelos son generados, pueden ser renderizados. Primero creamos un procedimiento para automatizar la creacin de actores de los ficheros de los modelos. Todos los elementos del pipeline son nombrados constantemente con el nombre de la parte siguiente por el nombre del elemento del pipeline. Esto facilita que el usuario identifique el objeto en cualquier sofisticado interfaz que este usando. Despus de un cdigo para crear la renderizacin requerida de los objetos, creamos un actor que podamos aadir al renderer.
5.15 Ejemplo
Como ejemplo de creacin de imgenes de cuerpos tridimensionales a partir de imgenes bidimensionales de cortes transversales obtenidas mediante un microscopio confocal, vamos a mostrar el cdigo necesario ( implementado en C++ ) para la reconstruccin 3D de una neurona madre:
/******************************************************************* //Como primer paso, incluimos las libreras necesarias para nuestra aplicacin: #include "vtkRenderer.h" #include "vtkRenderWindow.h" #include "vtkRenderWindowInteractor.h" #include "vtkImageReader.h" #include "vtkContourFilter.h" #include "vtkSmoothPolyDataFilter.h" #include "vtkPolyDataNormals.h" #include "vtkPolyDataMapper.h" #include "vtkActor.h" #include "vtkOutlineFilter.h" #include "vtkCamera.h" #include "vtkProperty.h" #include "vtkMergePoints.h" #include <fstream.h> #include <stdio.h> // Llevamos a cabo las definiciones de la longitud de la cabecera del archivo //(BIORAD_HEADER_LENGTH ), y de la macro que transforma datos tipo byte a //word #define BIORAD_HEADER_LENGTH 76
62
#define BYTE_TO_WORD(lsb,msb) (((unsigned char) lsb) + (((unsigned char) msb) << 8)) // Creamos la funcin main: int main( ) { //Creamos el renderer, renderwindow y rederwindowinteractor para poder visualizar //la imagen 3D resultado en una ventana de renderizacin: vtkRenderer *aRenderer = vtkRenderer::New(); vtkRenderWindow *renWin = vtkRenderWindow::New(); renWin->AddRenderer(aRenderer); vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New(); iren->SetRenderWindow(renWin); // El programa accede al nombre del fichero .pic, y al nmero de rodajas de que est //compuesta la imagen a travs de ficheros de texto .txt, y luego almacena los datos //en variables: int fd2, fd4, nx, ny, nz; unsigned char *head2 = new unsigned char[76]; fstream fd1; fd1.open("VTKFirstSlice.txt", ios::in); fd1 >> fd2; cout << " FirstSlice " << fd2; fd1.close(); fstream fd3; fd3.open("VTKLastSlice.txt", ios::in); fd3 >> fd4; cout << " LastSlice " << fd4; fd3.close(); fstream file1; file1.open("VTKFilename.txt", ios::in); file1.getline(file2, '\0'); cout << " Filename " << file2; file1.close(); //Abrimos el archivo de la imagen, comprobando antes que el nombre indicado por la //variable file2 es realmente un fichero .pic FILE *head1; head1 = fopen(file2,"rb");
if (head1 == NULL) std::cout << Error en la apertura del fichero"<<std::endl; return 0; //Leemos la cabecera del fichero PIC BIORAD fread(head2,sizeof(unsigned char),BIORAD_HEADER_LENGTH,head1); nx = BYTE_TO_WORD(head2[0], head2[1]); ny = BYTE_TO_WORD(head2[2], head2[3]); nz = BYTE_TO_WORD(head2[4], head2[5]); fclose(head1); //Verificamos si el numero de columnas, filas y rodajas del fichero son los correctos: if ( nx <= 0 ) std::cout << "Numero de columnas incorreto, " << nx << std::endl; return 0; if ( ny <= 0 ) std::cout << "Numero de filas incorreto, " << ny << std::endl; return 0; if ( nz <= 0 ) std::cout << "Numero de rodajas de imgenes incorrecto, " << nz <<std:: endl; return 0; nx = nx -1; ny = ny -1; nz = nz -1; //Creamos el ImageReader, objeto encargado de la lectura de la imagen, y establecemos sus parmetros: vtkImageReader *reader = vtkImageReader::New(); reader->SetFileName(nombreFich); reader->SetFileDimensionality(3); reader->SetDataExtent(0, nx, 0, ny, 0, nz); reader->SetDataVOI (0, nx, 0, ny, fd2, fd4); reader->SetDataOrigin(0, 0, 0); reader->SetDataScalarTypeToUnsignedChar(); reader->SetDataSpacing(1.0, 1.0, 0.2); reader->SetHeaderSize(76); // Aplicamos varios filtros a la imagen: primero el vtkContourFilter para la //superficie, y despus usamos el vtkPolyDataNormals para generar ejemplares que //sern alisados por el vtkSmoothPolyDataFilter durante la renderizacin.
vtkContourFilter *skinExtractor = vtkContourFilter::New(); skinExtractor->SetInput((vtkDataSet *) reader->GetOutput()); skinExtractor->SetValue(0, 254);
vtkSmoothPolyDataFilter *smooth = vtkSmoothPolyDataFilter::New(); smooth->SetInput(skinExtractor->GetOutput()); smooth->SetNumberOfIterations(50); smooth->BoundarySmoothingOn(); smooth->SetFeatureAngle(120); smooth->SetEdgeAngle(90); smooth->SetRelaxationFactor(.025); vtkPolyDataNormals *skinNormals = vtkPolyDataNormals::New(); skinNormals->SetInput(smooth->GetOutput()); skinNormals->SetFeatureAngle(60.0); // Creamos los actores y mappers necesarios para llevar a cabo la enderizacin: vtkPolyDataMapper *skinMapper = vtkPolyDataMapper::New(); skinMapper->SetInput(skinNormals->GetOutput()); skinMapper->ScalarVisibilityOff(); vtkActor *skin = vtkActor::New(); skin->SetMapper(skinMapper); vtkOutlineFilter *outlineData = vtkOutlineFilter::New(); outlineData->SetInput((vtkDataSet *) reader->GetOutput()); vtkPolyDataMapper *mapOutline = vtkPolyDataMapper::New(); mapOutline->SetInput(outlineData->GetOutput()); vtkActor *outline = vtkActor::New(); outline->SetMapper(mapOutline); outline->GetProperty()->SetColor(0,0,0); // Aadimos el objeto camera que nos permite posicionar el punto de vista a la hora //de la visualizacin por pantalla: vtkCamera *aCamera = vtkCamera::New(); aCamera->SetViewUp (0, 0, -1); aCamera->SetPosition (0, 1, 0); aCamera->SetFocalPoint (0, 0, 0); aCamera->ComputeViewPlaneNormal(); // Aadimos los actores al renderer creado anteriormente:
aRenderer->AddActor(outline); aRenderer->AddActor(skin); aRenderer->SetActiveCamera(aCamera); aRenderer->ResetCamera (); aCamera->Dolly(1.5); // Seleccionamos el color de fondo de la ventana de renderizacin y su tamao: aRenderer->SetBackground(1,1,1); renWin->SetSize(512, 512); aRenderer->ResetCameraClippingRange (); // Iniciamos la renderizacin: iren->Initialize(); iren->Start(); // Liberamos todos los objetos creados con el mtodo Delete ( ): smooth->Delete(); skinExtractor->Delete(); skinNormals->Delete(); skinMapper->Delete(); skin->Delete(); outlineData->Delete(); mapOutline->Delete(); outline->Delete(); aCamera->Delete(); iren->Delete(); renWin->Delete(); aRenderer->Delete();
return 0; } *******************************************************************/ El fichero CMakeLists.txt necesario para la ejecucin de CMake ser el siguiente: PROJECT ($eje_neuro)
INCLUDE (${CMAKE_ROOT}/Modules/FindVTK.cmake) IF (USE_VTK_FILE)

INCLUDE(${USE_VTK_FILE}) ENDIF (USE_VTK_FILE)
ADD_EXECUTABLE(neuro_Cont2 neuro_Cont2.cpp) TARGET_LINK_LIBRARIES(neuro_Cont2 vtkRendering)
A continuacin podemos ver la reconstruccin de la imagen 3D de la neurona madre, obtenida a partir de 32 cortes en 2D contenidos en un fichero .pic:
Figura 5.16: Imagen de una neurona madre obtenida tras su reconstruccin 3D a partir de 32 cortes en 2D, generada con VTK
67
68
6
6.1
Combinacin de la difusin
isotrpica y anisotrpica en el procesamiento de imgenes

Introduccin al filtrado de difusin
Por lo general, las etapas de procesamiento de imgenes se emplean en aplicaciones que pretenden conseguir la eliminacin de ruido o la regularizacin de las imgenes, intentando preservar la estructura de stas en ambos casos. Para esta finalidad se suele emplear el filtrado lineal, debido a su bajo coste computacional. Sin embargo, tiene como inconveniente la falta de realimentacin entre la zona concreta de la imagen que se est procesando y el filtrado al que est sometida. Regiones homogneas, son procesadas de igual manera. Una solucin a este problema surgida en los ltimos aos es la aplicacin de PDEs (Partial Differential Equations) sobre el procesamiento de imgenes. Mediante su empleo es posible aplicar un filtrado dependiente de las caractersticas del rea a procesar. Entre las PDE la ms empleada es la ecuacin de la difusin. Segn la analoga entre el campo escalar de las temperaturas en un proceso de difusin y el
Combinacin de la difusin isotrpica y anisotrpica en el procesamiento de imgenes
campo escalar del nivel de gris de una imagen en un filtrado de suavizado, las dinmicas de ambos procesos se rigen por la expresin:
t u = div(u )
donde u es el potencial del campo escalar y la ecuacin expresa la dinmica de un proceso de difusin homognea. La expresin es idntica a una convolucin de la imagen con una mscara de Gauss, cuya varianza est dada por:
2 = 2t
Este resultado tiene una interpretacin fsica. El nivel de gris, es en la analoga, un nivel de temperatura y tiende a homogenizarse en el tiempo, t. Por tanto, el suavizado de la imagen depende del tiempo transcurrido y desde el punto de vista de la implementacin con el valor de la varianza de la mscara de Gauss. El gran avance lo darn Perona y Malik al realizar por primera vez un filtrado de difusin isotrpica. La finalidad de este filtrado es acentuar el proceso de difusin en las zonas homogneas y preservar los bordes:
t u = div g u u
((
) )
siendo g(.) una funcin de g : m (m es la dimensin del campo escalar, u), decreciente con la magnitud del mdulo del gradiente. Su valor es prcticamente nulo en los bordes y prximo a 1 en regiones con valores similares de potencial. La funcin g(.) recibe el nombre de difusividad, y un proceso de difusin con una difusividad de tipo escalar se llama difusin isotrpica. Pero esta formulacin implica que en algunos puntos se d un proceso de difusin inversa, provocando el realce puntual del ruido. Para resolver sto, Weickert realiz un estudio de la difusin tomando la difusividad como un tensor de difusin en lugar de cmo un escalar:
t u = div(Du )
donde D es una matriz de dimensin mxm, simtrica y definida semi-positiva. El tensor D estar determinado por los autovectores y autovalores del tipo concreto de tensor:
D = RCRT
R es la matriz de rotacin y C es la matriz diagonal, cuyos elementos corresponden a los coeficientes de difusin en cada una de las componentes principales, de modo que al proyectarse el gradiente sobre el tensor, en la ecuacin de la difusin, se potencie el proceso de difusin en las direcciones de menor variabilidad, esto es, en direcciones perpendiculares a la componente principal de mayor autovalor. A este tipo de difusin, donde la difusividad es un tensor y no un escalar, se la denomina anisotrpica. Esta formulacin es extensible a cualquier dimensin de la imagen, y adems, se puede tambin generalizar a imgenes de valores de tipo vector,por lo que puede aplicarse al filtrado de imgenes en color. Para una imagen de vector u=(u1, u2, ..., un)T, la difusin isotropica quedar definida como:
n T t u = div g u j u j u j =1
Y la anisotrpica como:
n T t u = div D u j u j u j =1
En el caso de la difusin anisotrpica, el tensor emplea la propuesta de Di Zenzo para matrices con valores de vectores.
6.2
Difusin anisotrpica del realce de la coherencia local
En funcin de la aplicacin en concreto se definirn distintos tipos de tensor. Por ejemplo, en aplicaciones donde se pretende recuperar la coherencia local de la estructura de la imagen, perturbada generalmente por los sistemas de adquisicin, Weickert y Schnrr han propuesto el uso del tensor de difusin de realce de la coherencia local (CED - Coherence Enhancing Filtering). La estructura del tensor se basa en el producto del descriptor gradiente suavizado con su transpuesta y convolucionado con la mscara de Gauss K:
71
T S = K * u u
u = K * u K =
(2 )m / 2
u2 exp 2 2
donde S es una matriz que es invariante ante los cambios de signo de la direccin del gradiente, pero dependiente de su magnitud. El valor de la desviacin tpica depende de la escala del ruido y el valor de depende de la orientacin local. Los autovectores de S, para = 0, son paralelos y ortogonales a u . Con la ltima convolucin, con , se ha pasado de la direccin puntual del gradiente a la orientacin prominente estimada de la estructura local. A S se la conoce como tensor de estructura, operador de inters o matriz de segundo momento. Para realzar los patrones locales se propone que los coeficientes la matriz diagonal C sean dados por:
ci =
y
i = 2,..., m
k =0 c1 = + (1 ) exp C k
Habiendo ordenado las componentes de menor a mayor autovalor. Por tanto, la primera componente, estar indicando la direccin de mxima homogeneidad local en el nivel de irradiacin, esto es, de mnima variabilidad en esa direccin de esta componente principal. El valor de C es un umbral que se compara con el nivel de coherencia local y es un parmetro de difusividad que est en el intervalo (0,1), para garantizar el suavizado del tensor de difusin. Para medir si un entorno de vecindad es homogneo o no, se introduce la medida de coherencia local:
k = ( i j )
m i =1 i j
siendo i el autovector de la componente principal i de S(.). De forma que si los autovalores son similares, el ndice de coherencia, k, ser pequeo y los coeficientes
de difusin sern similares, dndose un proceso de difusin cuasi-isotrpica. Para el caso de discrepancias en los autovalores, indicar un entorno con componentes principales destacadas respecto de las otras, provocando un proceso de difusin anisotrpica en la direccin de menor variabilidad. Para imgenes 2D estn extendidas las expresiones analticas del tensor CED. Los autovalores de la matriz de segundo momento, S, valen:
1 =
1 (s11 + s12 ) 2 1 2 = (s11 + s12 + ) 2

2 (s11 s 22 )2 4s12
Y el tensor de difusin CED est definido por la matriz diagonal C y los autovalores de S:
d11 = d 22 = d12 =
(c2 c1 )(s11 s 22 ) 1 c c + + 1 2 2 (c1 c 2 )s12
(c 2 c1 )(s11 s 22 ) 1 c c + 1 2 2
Sin embargo, para el caso 3D se suele recurrir a mtodos numricos, implementado distintas variantes del mtodo numrico de Jacobi. Como alternativa, se pueden encontrar soluciones exactas mediante la teora matemtica de los invariantes (funciones escalares de la matriz que como el determinante no cambian al cambiar de base). El clculo de los autovalores de un tensor simtrico de orden 3 requiere introducir los siguiente invariantes de la matriz de segundo momento:
73
I 1 = tr (S ) I2 =
1 2 tr S 2 tr (S ) 2 I 3 = det (S )
~ 1 S = S I1 I 3
(( )
que sirven para calcular los invariantes de la componente desviadora de S, :
J2 =
1 ~ ~2 1 tr S 2 tr S = I 12 + 3I 2 3 2 ~ 1 2 I 13 + 9 I 1 I 2 + 27 I 3 J 3 = det S = 27
((
) ( )) (
(
) )
()
que a su vez permite calcular el ngulo de Lode:
cos(3 ) =
3 3 J3 3/ 2 2 J2
Y se puede demostrar que los autovalores del tensor S ordenados de menor a mayor son:
1 = I1 + 2 2 = I1 + 2 3 = I1 + 2
1 3 1 3
1 3
J2 2 cos + 3 3 J2 2 cos 3 3 J2 cos( ) 3
El clculo de los elementos del tensor ser funcin de la matriz de segundo momento, de los coeficientes de difusividad en cada componente y de los autovalores. El tensor de difusin D se reconstruye a partir de la matriz de rotacin R y de una matriz diagonal C de difusin, segn:
74
C = RDR t , por tanto:
Dij = c1 R1i R1 j + c2 R2i R2 j + c3 R3i R3 j

y se obtiene:
%+ s )(S % +s ) ck (S i3 i3 k j3 j3 k Dij = si i, j =1,2 2 2 2 2 % % % S s S s S s s ( ) ( ) ( ( ) ) + + + + + + k=1 i3 j3 k j3 j3 k k 33 11 22 k

k
%+ s )(S % +(s + s ) 2) ck (S i3 i3 k k 33 11 22 k Di3 = si i =1,2 2 2 2 2 % % % k=1 (Si3 + sj3k ) +(Sj3 + sj3k ) + (S33 +(s 11 + s22 )k k )
k
% +(s + s ) 2)2 ck (S 33 11 22 k k D33 = 2 2 2 2 % % % k =1 (Si3 + sj3k ) +(Sj3 + sj3k ) +(S33 +(s 11 + s22)k k )
k
% el adjunto ij de la matriz S. siendo S ij Esta forma de calcular el tensor de difusin en 3D agiliza el tiempo de cmputo, respecto a los mtodos numricos, casi en un orden de magnitud.
6.3
Condiciones de difusin anisotrpica e isotrpica de CED
Para el caso del tensor CED se observa que cuando los autovalores de la matriz de segundo momento son muy similares, todas las componentes tienen aproximados coeficientes de difusividad, en este caso, el tensor se convierte en una matriz diagonal ponderada por el parmetro de difusin . La decisin en un pxel determinado de realizar difusin isotrpica o anisotropica depende del nivel de umbral, C, y de la medida de coherencia local, k. Segn la ecuacin,
k =0 c1 = + (1 ) exp C k
vista anteriormente, la difusin ser anisotrpica cuando la medida de coherencia local sea mayor a cero, pero si se relaja la condicin con una aportacin significativa del valor de , ello permitir definir el nivel de umbral, C, a partir de la informacin
de la imagen. As, una vez obtenido el ndice de coherencia local, k, en cada pxel de la imagen a procesar, se tendr su rango dinmico, pudiendo definir el valor de C como:
1 C = k * log f 1
Siendo f la fraccin de que se considere significativa para pasar de difusin isotrpica a anisotrpica, y k* el nivel de medida de coherencia local en la que se va a empezar a aplicar la difusin anisotrpica. Por tanto, para valores de medida de coherencia local mayor a k* se tendr difusin anisotrpica y en caso contrario, ser difusin isotrpica. De esta forma ser posible definir el valor del umbral, C, mediante una visualizacin previa del ndice de coherencia en cada uno de los pxeles. Esta propiedad, adems, puede ser aprovechada para agilizar los tiempos de computacin, ya que si la medida de coherencia local, k, est por debajo de k*, no se calcular el tensor y se sustituir por la matriz diagonal I. En caso contrario, se proceder a determinar el tensor. El valor de k depende de si se procesan imgenes 2D o 3D. Para el caso 2D, la medida local de coherencia coincide con 2 y en 3D con el invariante J2:
k = ( i j ) = 2
2 2 i =1 i j 3
(2 D ) (3D )
k = ( i j ) = 6 J 2
2 i =1 i j
Aprovechando esta propiedad, las reducciones de tiempo de computacin dependern de la naturaleza de la imagen a procesar. En el caso 2D, por cada pxel de similares autovalores, el ahorro es de 15 sumas, 3 multiplicaciones, 7 divisiones y 2 potencias. Ms significativo es el caso de 3D, donde se ahorrara 232 sumas, 211 multiplicaciones, 68 potencias y 4 operaciones trigonomtricas.
6.4
Combinacin de la difusin isotrpica y anisotrpica
En imgenes con mucho ruido, el nivel de coherencia local, k, se ve muy afectado, alterndose por una prdida de las verdaderas componentes principales. En estos casos puede resultar interesante realizar una bsqueda de patrones dentro del propio ruido, por ejemplo realzando el flujo o tendencias existente dentro de la propia imagen ruidosa. Pero cuando se pretende determinar la estructura de los
cuerpos presentes en la imagen y suponga la preservacin de los bordes, los resultados de la difusin anisotrpica fallan. Esto se debe en gran medida, a que la intencin del CED es buscar y realzar los patrones de la imagen y no la eliminacin del ruido. Cuando ste aparece, el nivel de coherencia local disminuye y CED tiende a tener un comportamiento isotrpico. La difusividad se ha convertido en un escalar, . Pero esta constante, ni siquiera depende de la magnitud del mdulo del gradiente. Debido a sto, resulta ms interesante eliminar previamente el ruido a partir de una difusin isotrpica. Luego, una vez preprocesada, la imagen est preparada para poder realzar los patrones existentes.
6.4.1 Resultados de difusin isotrpica y anisotrpica. Ejemplos Comenzaremos con un ejemplo de difusin en 2D. En la serie de figuras 6.1, tenemos una imagen sinttica cuyos bordes se han desvirtuado tras ser sometida a ruido gausiano. La imagen 6.1.a muestra la fuente. A la 6.1.b se le ha aplicado un filtrado tipo CED. El resultado es que el propio ruido ha generada marcas de patrones aleatorios.
Figura 6.1.a: Imagen sinttica con ruido blanco
Figura 6.1.b: Imagen procesada con CED
En la figura 6.1.c podemos ver la misma imagen tras la aplicacin de un filtrado de difusin isotrpico. Tiene un buen comportamiento en la eliminacin del ruido, pero ste no es efectivo en la conservacin del borde, ya que carece de la informacin local de la estructura. Por ltimo, como vemos en la figura 6.1.d, si al resultado del filtrado isotrpico se sigue con otra etapa de difusin CED, el resultado del procesado resulta ptimo. Se ha eliminado el ruido y se han conservado los bordes sintticos.
77
Figura 6.1.c: Imagen procesada con difusin isotrpica
Figura 6.1.d: Imagen procesada con difusin isotrpica y difusin CED
El siguiente ejemplo muestra una aplicacin de difusin 3D para la reconstruccin 3D de una neurona madre empleando microscopia confocal. Podemos ver las diferentes etapas en la serie de figuras 6.2: La primera figura (6.2.a) muestra la fuente, que posee cierto grado de ruido tras etapa de adquisicin. Tras aplicarle un filtrado de difusin isotrpica (figura 6.2.b), presenta buenos resultados en la eliminacin del ruido, sin embargo, no es capaz de preservar la estructura del cuerpo biolgico.
Figura 6.2.a: Rodaja de una pila de imgenes proveniente de un confocal sobre una neurona madre
Figura 6.2.b: Imagen procesada con CED
En la figura 6.2.c podemos observar el resultado tras la aplicacin de CED. sta hace aparecer terminaciones de la neurona que son falsas, debido al realce de
patrones que estn fuera del campo de visin. Finalmente, obtenemos los resultados ptimos con una combinacin de difusin isotrpica y anisotropica, como muestra la figura 6.2.d.
Figura 6.2.c: Imagen procesada con difusin Figura 6.2.d: Imagen procesada isotrpica con difusin isotrpica y difusin CED
Finalmente, comparando las figura 6.3.a y b, podemos apreciar los efectos de una combinacin apropiada de difusin isotrpica y difusin CED tras llevar a cabo la reconstruccin 3D de la neurona madre.
Figura 6.3.a: Reconstruccin 3D de una pila de imgenes proveniente de un confocal sobre una neurona madre
Figura 6.3.b: Reconstruccin 3D con filtrado combinado de disusin isotrpica y anisotrpica
Como ltimo ejemplo, en las figuras de la serie 6.4, podemos comprobar como las tcnicas de difusin tambin son vlidas para el filtrado de imgenes en color. La primera imagen ( figura 6.4.a ), muestra una aplicacin de procesado de imgenes de espermatozoides. El objetivo es facilitar la segmentacin de los nucleoides y de los halos de los espermatozoides. La imagen 6.4.b ha sido tratada con un filtrado de difusin isotrpica. Podemos apreciar como sta desdibuja los nucleoides de los halos, pero elimina eficazmente el ruido de fondo.
Figura 6.4.a: Imgenes de espermatozoides con fragmentacin del ADN
Figura 6.4.b: Imagen procesada con difusin isotrpica
80
La figura 6.4.c corresponde al resultado de una difusin CED en color. Con ella se realzan los patrones de los halos y los nucleoides, pero persiste el ruido. Finalmente, podemos apreciar de nuevo como los mejores resultados se dan con la combinacin de ambos procesos de difusin ( figura 6.4.d ).
Figura 6.4.c: Imagen procesada con difusin CED
Figura 6.4.d: Combinacin de difusin isotropica y anisotropica
Por ltimo, en la siguiente tabla tenemos una comparativa entre los tiempos de cmputo del clculo del tensor CED empleando mtodos numricos y con las expresiones analticas presentadas. Estas diferencias de tiempos llegan casi a dos rdenes de magnitud en el caso 2D y un orden de magnitud en 3D.
Tamao 64x64 128x128 256x256 512x512 32x32x32 64x64x64
Numrico 187,5ms 781,4ms 3.760,9ms 19.907,9ms 2.987,4 ms 25.370,6ms
Simblico 3,1ms 13,7ms 57,6ms 206,3ms 365.4ms 4.020,1ms
Ratio 60,48 57,03 65,29 96,49 8.71 6.31
Figura 6.5: Tiempos de cmputo del tensor CED en un P-IV a 2.40GHz
81
Con la determinacin de las expresiones analticas de los tensores 3D, en funcin de la matriz de segundo momento y de los coeficientes de difusin, se ha conseguido reducciones del tiempo de computacin, casi en un orden de magnitud respecto a los mtodos numricos.
82
Aplicacin del filtrado de
difusin con imgenes JPG y PIC

En este captulo vamos a describir el proceso de creacin de una aplicacin que emplea las herramientas de visualizacin de imgenes en dos y tres dimensiones que nos proporcionan las libreras de VTK , as como las de filtrado de difusin isotrpica y anisotrpica, todo ello implementado en C++. Para llevar a cabo su desarrollo se ha utilizado el modelo UML y la aplicacin Rational Rose.
7.1 Modelado UML

7.1.1 Introduccin El paradigma orientado a objetos enfatiza la creacin de clases que encapsulan tanto los datos, como los algoritmos que se utilizan para manejar los datos. Si se disean y desarrollan adecuadamente las clases orientadas a objetos, stas pueden reutilizarse en diferentes aplicaciones y arquitecturas de sistemas basados en computadoras.
83
Aplicaciones del filtrado de difusin con imgenes .jpg y .pic
El modelo de proceso basado en componentes es un enfoque incremental, iterativo, que permite configurar aplicaciones desde componentes preparados de software, llamados clases. La actividad se inicia con la identificacin de las clases candidatas, examinando los datos que se van a manejar por parte de la aplicacin y los algoritmos que se requieren para obtener la funcionalidad especificada como requerimiento. Los datos y algoritmos correspondientes se empaquetan en clases. Las clases creadas se almacenan en una biblioteca de clases o diccionario de datos. Cuando se realiza una nueva aplicacin y ya se han identificado las clases candidatas, se examina si existen en la biblioteca para su uso, o bien si no existen se crean. De esta forma se desarrolla la primera iteracin de la aplicacin mediante las clases extradas de la biblioteca y las clases nuevas construidas para cumplir con las necesidades especficas del proyecto. El flujo del proceso vuelve a la espiral incremental para aadir funcionalidad al proyecto y volver a introducir la iteracin de nuevos componentes al sistema. Este modelo basado en componentes conduce a la reutilizacin de software, brindando importantes beneficios al grupo desarrollador. Para definir los componentes que se utilizarn para construir el sistema y sus interfaces, se propuso utilizar el Lenguaje Unificado de Modelado (UML) [Booch, 1999], que conjunta las mejores caractersticas de los mtodos de anlisis y diseo orientados a objetos y hoy en da se ha convertido en el mtodo ms utilizado en la industria. A finales de la dcada de 1990, Grady Booch, James Rambaugh e Ivar Jacobson colaboraron para combinar y recopilar las mejores caractersticas de sus mtodos, adoptando los siguientes objetivos: Representar sistemas completos, en lugar de solamente la parte de software, usando conceptos orientados a objetos. Establecer una relacin explcita entre conceptos y cdigo ejecutable. Crear un lenguaje de modelado que pudiera ser usado por humanos y mquinas. El resultado fue un mtodo unificado, denominado UML ( Unified Modeling Language, o Lenguaje de Modelado Unificado ), que con bastante aceptacin y xito se ha empleado por nmero importante de desarrolladores de software para las labores de anlisis y diseo de sistemas orientados a objetos. UML presenta las ventajas de poder utilizarse como un lenguaje estndar, principalmente grfico, para visualizar, especificar, construir y documentar los productos de un sistema de software. Se puede emplear con todos los procesos, a lo
84
largo del ciclo de vida de desarrollo y a travs de diferentes tecnologas de implementacin.
7.1.2 Modelado visual Tal como indica su nombre, UML es un lenguaje de modelado. Un modelo es una simplificacin de la realidad. El objetivo del modelado de un sistema es capturar las partes esenciales del sistema. Para facilitar este modelado, se realiza una abstraccin y se plasma en una notacin grfica. Esto se conoce como modelado visual. El modelado visual permite manejar la complejidad de los sistemas a analizar o disear. De la misma forma que para construir una choza no hace falta un modelo, cuando se intenta construir un sistema complejo como un rascacielos, es necesario abstraer la complejidad en modelos que el ser humano pueda entender. UML sirve para el modelado completo de sistemas complejos, tanto en el diseo de los sistemas software como para la arquitectura hardware donde se ejecuten. Otro objetivo de este modelado visual es que sea independiente del lenguaje de implementacin, de tal forma que los diseos realizados usando UML se pueda implementar en cualquier lenguaje que soporte las posibilidades de UML (principalmente lenguajes orientados a objetos). UML es adems un mtodo formal de modelado. Esto aporta las siguientes ventajas: Mayor rigor en la especificacin. Permite realizar una verificacin y validacin del modelo realizado. Se pueden automatizar determinados procesos y permite generar cdigo a partir de los modelos y a la inversa (a partir del cdigo fuente generar los modelos). Esto permite que el modelo y el cdigo estn actualizados, con lo que siempre se puede mantener la visin en el diseo, de ms alto nivel, de la estructura de un proyecto.
7.1.3 Qu es UML? UML es ante todo un lenguaje. Un lenguaje proporciona un vocabulario y una reglas para permitir una comunicacin. En este caso, este lenguaje se centra en la representacin grfica de un sistema. Este lenguaje nos indica cmo crear y leer los modelos, pero no dice cmo crearlos. Esto ltimo es el objetivo de las metodologas de desarrollo.
Los objetivos de UML son muchos, pero se pueden sintetizar sus funciones: Visualizar: UML permite expresar de una forma grfica un sistema de forma que otro lo puede entender. Especificar: UML permite especificar cules son las caractersticas de un sistema antes de su construccin. Construir: A partir de los modelos especificados se pueden construir los sistemas diseados. Documentar: Los propios elementos grficos sirven como documentacin del sistema desarrollado que pueden servir para su futura revisin. Aunque UML est pensado para modelar sistemas complejos con gran cantidad de software, el lenguaje es los suficientemente expresivo como para modelar sistemas que no son informticos, como flujos de trabajo (workflow ) en una empresa, diseo de la estructura de una organizacin y por supuesto, en el diseo de hardware. Un modelo UML esta compuesto por tres clases de bloques de contruccin: Elementos: Los elementos son abstracciones de cosas reales o ficticias (objetos, acciones, etc.) Relaciones: relacionan los elementos entre s. Diagramas: Son colecciones de elementos con sus relaciones.
7.1.4 Diagramas UML Un diagrama es la representacin grfica de un conjunto de elementos con sus relaciones. En concreto, un diagrama ofrece una vista del sistema a modelar. Para poder representar correctamente un sistema, UML ofrece una amplia variedad de diagramas para visualizar el sistema desde varias perspectivas. UML incluye los siguientes diagramas: Diagrama de casos de uso. Diagrama de clases. Diagrama de objetos. Diagrama de secuencia.
86
Diagrama de colaboracin. Diagrama de estados. Diagrama de actividades. Diagrama de componentes. Diagrama de despliegue. Los diagramas ms interesantes (y los ms usados) son los de casos de uso, clases y secuencia, por lo que nos centraremos en stos. Para ello, se utilizar ejemplos de un sistema de venta de entradas de cine por Internet. El diagrama de casos de usos representa grficamente los casos de uso que tiene un sistema. Se define un caso de uso como cada interaccin supuesta con el sistema a desarrollar, donde se representan los requisitos funcionales. Es decir, se est diciendo lo que tiene que hacer un sistema y cmo. En la figura 7.1 se muestra un ejemplo de casos de uso, donde se muestran tres actores (los clientes, los taquilleros y los jefes de taquilla) y las operaciones que pueden realizar (sus roles).
Figura 7.1: Diagrama de casos de uso
El diagrama de clases muestra un conjunto de clases, interfaces y sus relaciones. ste es el diagrama ms comn a la hora de describir el diseo de los
sistemas orientados a objetos. En la figura 7.2 se muestran las clases globales, sus atributos y las relaciones de una posible solucin al problema de la venta de entradas.
Figura 7.2: Diagrama de clases
En el diagrama de secuencia se muestra la interaccin de los objetos que componen un sistema de forma temporal. Siguiendo el ejemplo de venta de entradas, la figura 7.3 muestra la interaccin de crear una nueva sala para un espectculo. El resto de diagramas muestran distintos aspectos del sistema a modelar. Para modelar el comportamiento dinmico del sistema estn los de interaccin, colaboracin, estados y actividades. Los diagramas de componentes y despliegue estn enfocados a la implementacin del sistema.
88
Figura 7.3: Diagrama de secuencia
7.1.5 Proceso de desarrollo Aunque UML es bastante independiente del proceso de desarrollo que se siga, los mismos creadores de UML han propuesto su propia metodologa de desarrollo, denominada el Proceso Unificado de Desarrollo. El Proceso Unificado est basado en componentes, lo cual quiere decir que el sistema software en construccin est formado por componentes software interconectados a travs de interfaces bien definidos. Adems, el Proceso Unificado utiliza el UML para expresar grficamente todos los esquemas de un sistema software. Pero, realmente, los aspectos que definen este Proceso Unificado son tres: es iterativo e incremental, dirigido por casos de uso y centrado en la arquitectura: Dirigido por casos de uso: Basndose en los casos de uso, los desarrolladores crean una serie de modelos de diseo e implementacin que los llevan a cabo. Adems, estos modelos se validan para que sean conformes a los casos de uso. Finalmente, los casos de uso tambin sirven para realizar las pruebas sobre los componentes desarrollados.
89
Centrado en la arquitectura: En la arquitectura de la construccin, antes de construir un edificio ste se contempla desde varios puntos de vista: estructura, conducciones elctricas, fontanera, etc. Cada uno de estos aspectos est representado por un grfico con su notacin correspondiente. Siguiendo este ejemplo, el concepto de arquitectura software incluye los aspectos estticos y dinmicos ms significativos del sistema. Iterativo e incremental: Todo sistema informtico complejo supone un gran esfuerzo que puede durar desde varios meses hasta aos. Por lo tanto, lo ms prctico es dividir un proyecto en varias fases. Actualmente se suele hablar de ciclos de vida en los que se realizan varios recorridos por todas las fases. Cada recorrido por las fases se denomina iteracin en el proyecto en la que se realizan varios tipos de trabajo (denominados flujos). Adems, cada iteracin parte de la anterior incrementado o revisando la funcionalidad implementada. Se suele denominar proceso.
Figura 7.4: Proceso iterativo e incremental Resumiendo, el Proceso Unificado es un modelo complejo con mucha terminologa propia, pensado principalmente para el desarrollo de grandes proyectos. Es un proceso que puede adaptarse y extenderse en funcin de las necesidades de cada empresa.
90
7.2 La herramienta Rational Rose

Rational Rose es una herramienta CASE software para el modelado visual, mediante UML, de sistemas software. Permite especificar, analizar y disear el sistema antes de codificarlo, manteniendo la consistencia de los modelos del sistema software. Utilizando la sintaxis del modelado UML, permite la generacin de documentacin automticamente, y la generacin de cdigo a partir de los modelos (en varios lenguajes de programacin como Java o C++), as como la aplicacin de ingeniera inversa (crear modelos a partir de cdigo).
Figura 7.5: Logo de Rational
Integrando los ambientes de modelado y desarrollo, y utilizando el Unified Modeling Language (UML), Rational Rose permite que todos los miembros de equipo desarrollen individualmente, se comuniquen colaborativamente y produzcan mejor software. Con la capacidad de crear arquitecturas basadas en componentes flexibles, Rational Rose permite que los procesos de software evolucionen en forma controlada, administrada e identificable, reduciendo los costos y acelerando los tiempos de entrega. Por todos estos motivos, la herramienta Rational Rose ha sido la elegida para desarrollar nuestra aplicacin de visualizacin y filtrado de imgenes.
7.3 Documentacin de la aplicacin difusin2D3D

El programa difusin2D3D es el resultado prctico del desarrollo de una aplicacin mediante las tcnicas de modelado UML y la herramienta Rational Rose. Para llevar a cabo su elaboracin segn el modelo UML, antes de implementar el cdigo del programa es necesario completar una serie de documentos que nos permitirn una rpida y fcil asimilacin de los objetivos y el funcionamiento de la aplicacin, as como su viabilidad, alcance y restricciones.
91
7.3.1 Visin y alcance de la aplicacin El primero de los documentos a rellenar es el de "visin y alcance", ya que en l se reflejarn las caractersticas ms importantes del proyecto. Este documento pone de acuerdo a clientes y desarrolladores. Adems de una visin global del sistema, tambin incluye su justificacin de mercado y sus limitaciones. El documento de visin y alcance se divide en varias categoras, y a su vez stas se descomponen en distintos apartados, los cules se exponen a continuacin.
7.3.1.1 Requerimientos del negocio <Los requisitos del negocio proporcionan el origen y la referencia para todo el desarrollo de los requisitos detallados. Se puede recolectar requisitos del negocio del cliente desde un patrocinador ejecutivo, un visionario del proyecto, gerencia de producto, el departamento de la comercializacin, u otros individuos que tienen un sentido claro de porqu se est emprendiendo el proyecto y el ltimo valor que proporcionar, al negocio y a los clientes.> 7.3.1.1.1 Introduccin <Esta seccin resume el anlisis razonado para el nuevo producto. Proporcione una descripcin general de la historia o situacin que haya decidido la construccin de este producto.> Se pretende realizar una plataforma para el anlisis de imgenes 2D y 3D empleando tcnicas de difusin isotrpica y anisotrpica. Las imgenes sern en niveles de grises y en color para 2D y en 3D, slo en niveles de grises. En esta plataforma se cubrir los siguientes aspectos: - Visualizacin de imgenes 2D dentro de un GUI - Visualizacin de imgenes 3D dentro de un GUI con toda facilidad del procesos de reconstruccin 3D: conversin del dominio de la imagen al dominio geomtrico (marching cubes,...), reduccin de puntos, suavizado, etc - Filtrados isotrpicos y anisotrpicos - Aperturas de ficheros de imgenes 3D de tipo PIC - Procesamiento distribuido
92
7.3.1.1.2 Oportunidad del negocio <En esta seccin se describe la oportunidad del mercado que existe o el problema que se pretende solucionar. Describe el mercado en el cual el producto comercial competir o el ambiente en el cual el sistema de informacin ser utilizado. Esto puede incluir una breve evaluacin comparativa de productos existentes y de soluciones potenciales, indicando porqu el producto propuesto es atractivo.> Ser una plataforma abierta para la investigacin de las tcnicas de difusin isotrpicas y anisotrpicas de imgenes 2D y 3D, capaces de realizar visualizacin de los resultados y procesamientos distribuido.
7.3.1.1.3 Objetivos esenciales y criterios de xito <En este apartado se describen los objetivos de negocio importantes del producto en una manera que sea cuantitativa y medible. El valor proporcionado a los clientes se describe en la seccin 1.4, en esta seccin tan slo debe centrarse en el valor proporcionado al negocio. Esto poda incluir estimaciones de los ahorros de coste, vuelta en anlisis de inversin, o fechas del lanzamiento del producto. Determnese cmo el xito ser definido y medido en este proyecto, y describa los factores que son probables para tener el ms grande de los impactos en la realizacin con xito del proyecto. Incluya las cosas dentro del control directo de la organizacin, as como factores externos. Establezca los criterios medibles para determinar si se han resuelto los objetivos de negocio.> 1. Visualizacin de las imgenes 2D y 3D: Se podrn visualizar las imgenes de entrada, contenidas en un fichero, y tambin las generadas del proceso de filtrado 2. Se implementarn los filtros 2D y 3D de difusin isotrpica y anisotrpica 3. El procesamiento podr ser elegido de tipo distribuido
7.3.1.1.4 Necesidades de los usuarios <Esta seccin describe las necesidades de los clientes tpicos o de segmentos de mercado, incluyendo las necesidades que todava no son satisfechas por el mercado o por los sistemas existentes. Se pueden describir los problemas que los clientes encuentran actualmente y cmo el producto sera utilizado por los futuros clientes. Hay que identificar el ambiente del hardware y del software del cliente en el cual el producto debe funcionar. Se debe definir en un alto nivel cualquier requisito crtico sabido de interfaz o de funcionamiento. Hay que evitar incluir cualquier detalle del diseo o de la puesta en prctica. Los requisitos se presentan en una lista
93
numerada para poder cumplir los objetivos del usuario, tambin llamados, requisitos funcionales.> 1. Tener una plataforma abierta para poder investigar nuevos algoritmos de visin para el procesamiento de imgenes 2D y 3D. Esta plataforma deber ser bancada para las nuevas libreras de anlisis de imgenes, tales como VTK e ITK.
7.3.1.1.5 Riesgos del negocio <Aqu se sumarizan los mayores riesgos del negocio asociado con el desarrollo de este producto, tales como la competencia en el Mercado, los tiempos de realizacin, la aceptacin de los usurarios, los tipos de implementacin o posibles impactos negativos sobre el negocio. Hay que estimar la diversidad de los riesgos y cmo se podran mitigar.> Esta plataforma ser un framework de futuros proyectos y de nuevos trabajos de investigacin. Deber ser abierta y con capacidad para poder cambias de nuevas libreras de servicio, por ejemplo, sustituir las VTK por otras. Los riesgos que se tienen son: 1. Que la plataforma sea difcil de mantener y de aumentar 2. Que este ligado los aspectos de visualizacin con los de procesamiento 3. La documentacin debe ser abundante 4. No est claro cmo se realizarn las tcnicas de anlisis de imgenes con un procesamiento distribuido en la red
7.3.1.2 Visin de la solucin <Esta seccin establece una visin a largo plazo para que el sistema sea construido cumpliendo los objetivos de negocio. Esta visin proporcionar el contexto para tomar decisiones a travs del curso del ciclo vital del desarrollo de producto. La visin no debe incluir requisitos o la informacin funcionales detallados del planeamiento del proyecto.>
7.3.1.2.1 Visin global <Aqu se presenta una declaracin sucinta de la visin que resuma el propsito y el intento del producto nuevo y describa cules ser el mundo cuando se incluye el producto. La declaracin de la visin debe reflejar una visin equilibrada que satisfaga las necesidades de clientes diversos as como de la organizacin
posible del proyecto. Puede ser algo idealista, pero debe ser puesto a tierra en las realidades de los mercados existentes o de los anticipados cliente, arquitecturas de las empresa, direcciones estratgicas de organizacin, y limitaciones del coste y del recurso.> El programa "difusion2D3D" permitir visualizar imgenes en dos y tres dimensiones, as como sus respectivos filtrados de difusin. Se necesitar la imagen inicial a filtrar. El programa generar un archivo de imagen con el resultao del filtrado.
7.3.1.2.2 Principales caractersticas <Este apartado incluye una lista numerada de las caractersticas principales del producto nuevo, acentuando aquellas caractersticas que lo distinguen de anterior versiones o de productos de competencia. Las exigencias del consumidor especficas y los requisitos funcionales se pueden retomar de nuevo a estas caractersticas.> 1. Anlisis de las imgenes: a) Visualizacin de imgenes 2D provenientes de ficheros o del resultado final de la etapa de procesamiento b) Procesamiento de imgenes 2D con filtrados de difusin isotrpico y anisotrpico, tanto en imgenes en niveles de grises como en color c) Procesamiento de imgenes 3D con filtrados de difusin isotrpico y anisotrpico ( slo en niveles de grises ) d) Reconstruccin 3D siguiendo el proceso VTK 2. Procesamiento distribuido de las etapas de filtrado 3. Realizacin de GUI independientes de la plataforma
7.3.1.2.3 Suposiciones y dependencias <Esta seccin registra cualquier hiptesis que fuera hecha al concebir el proyecto y al escribir este documento de visin y del alcance. Hay que observar cualquier dependencia importante que el proyecto deba confiar para el xito, por ejemplo tecnologas especficas, vendedores de tercera persona, socios del desarrollo, u otras relaciones del negocio.> - El formato de las imgenes sern las soportadas por las VTK, aadiendo las imgenes tipo PICs
95
7.3.1.3 Alcance y restricciones <El alcance del proyecto define el concepto y la gama de soluciones propuestas. Es tambin importante definir qu no ser incluida en el producto. Clarificar el alcance y las limitaciones para establecer expectativas realistas de las distintas soluciones. Tambin proporciona un marco de la referencia para nuevas caractersticas propuestas y los cambios de los requisitos que puedan ser evaluados. Los requisitos propuestos que estn fuera de alcance del producto previsto se deben rechazar, a menos que sean tan beneficiosos que su repercusin sean muy importante>
7.3.1.3.1 Caractersticas principales en la primera versin <En esta seccin se describen las caractersticas principales previstas que sern incluidas en el lanzamiento inicial del producto. Hay que considerar las ventajas que el producto se piensa puede atraer a las varias comunidades del cliente, y describir generalmente las caractersticas de producto y las caractersticas de la calidad que le permitirn proporcionar esas ventajas. Evitar la tentacin de incluir cada caracterstica posible que cualquier categora potencial del cliente pudo concebir en un cierto da. Hay que centrarse en esas caractersticas y caractersticas del producto que proporcionen la mayora del valor, en el coste ms aceptable del desarrollo, y de mayor inters a la comunidad ms amplia.> 1. Visualizacin de imgenes 2D y 3D 2. GUI independientes de la plataforma 3. Filtrados de difusin isotrpicos y anisotrpicos 4. Procesamiento distribuido de las tareas de filtrado
7.3.1.3.2 Mejoras en las siguientes versiones < Aqu se indica qu caractersticas importantes se podrn dar en versiones posteriores.> 1. Escenarios AOS 2. Nuevas propuestas de filtros de difusin isotrpica y anisotrpica 3. Procesamiento distribuido inteligente (p. Ej. Marching cubes, ...)
7.3.1.3.3 Limitaciones y Exclusiones <En este apartado se identifica cualesquier caracterstica del producto que se pudiera anticipar, pero que no se planean para ser incluidas en el proyecto.> - El tiempo de procesamiento no estar limitado.
7.3.2 Casos de uso Los siguientes documentos a rellenar son los de los "casos de uso". En ellos se describen los distintos requisitos funcionales de la aplicacin. Para cada caso de uso, se indican, entre otras cosas, los actores que intervienen, su curso de xito, las precondiciones y postcondiciones o las excepciones al curso de xito. En la aplicacin "difusin2D3D" se han desarrollado cuatro casos de uso: - Visualizar 2D - Visualizar 3D - Filtrar difusin 2D - Filtrar difusin 3D A continuacin se incluye la descripcin de cada uno de ellos que, al igual que en el documento de visin y alcance, se subdividen en distintas secciones y apartados.
7.3.2.1
Caso de uso visualizar 2D
7.3.2.1.1 Actor <Un actor es la persona o entidad externa al sistema de software que trabaja con el sistema y realiza casos del uso para lograr tareas. Diversos agentes corresponden a menudo a diversas clases del usuario, o papeles, definiendo la comunidad del cliente que utilizar el producto. Nombre del actor(s) que realizar este caso del uso.> Usuario
7.3.2.1.2 Descripcin <Este apartado proporciona una breve descripcin de la razn y del resultado de este caso del uso, o una descripcin de alto nivel de la secuencia de acciones y del resultado al ejecutar el caso del uso> El usuario indica el nombre de una imagen 2D en escalas de grises o en color con extensin JPG. El sistema leer y abrir el fichero permitiendo su visualizacin.
7.3.2.1.3 Precondiciones <Aqu se enumera cualquier actividad que deba ocurrir, o cualquier condicin que deban ser verdaderas, antes de que el caso del uso pueda ser comenzado. Se numera cada condicin previa.> 1. Las imgenes son 2D y tienen el formato JPG.
7.3.2.1.4 Poscondiciones <Se describe el estado del sistema en la conclusin de la ejecucin del caso del uso. Se numera cada postcondition.> 1. Al indicar el nombre de la imagen, aparece una pantalla en la que se visualiza dicha imagen.
7.3.2.1.5 Curso de xito <En este apartado se hace una descripcin detallada de cmo acta el sistema ante este caso de uso, en su curso de xito o normal, evitando las bifurcaciones. Esta descripcin se realizar a modo de estados en el que evoluciona el sistema en la realizacin del caso de uso. La enumeracin ser con X.0, donde X es el ID del uso de caso.> 1.0 El usuario abre un browser para buscar las imgenes JPG. 2.0 El usuario busca y elige la imagen a visualizar. 3.0 El nombre de esta imagen y su localizacin se carga en el programa. 4.0 Se abre una ventana en que se visualiza la imagen elegida.
98
7.3.2.1.6 Curso alternativo <Cursos alternativos y legtimos del uso que pueden ocurrir dentro de este caso de uso. Se indica el curso alternativo, y se describe cualquier diferencia en la secuencia de los pasos que ocurren. Se numera cada curso alternativo en la forma "X.Y ", donde "X" identifica el caso de uso y la Y es un nmero de serie para la alternativa. Por ejemplo, "5.3" indicaran el tercer curso alternativo para el caso nmero 5 del caso de uso.> 1.1 El usuario carga directamente el nombre de la imagen.
7.3.2.1.7 Excepciones <En este apartado se describe cualquier condicin de error anticipada que podra ocurrir durante la ejecucin del caso de uso, y se define cmo el sistema es capaz de responder a estas condiciones. Tambin, se describe cmo el sistema responde si la ejecucin del caso de uso falla por una cierta razn inesperada. Se numera cada curso alternativo en la forma "X.Y.E.Z ", donde "X" identifica el caso del uso, Y indica (0) normal o el curso alternativo (>0) durante los cuales esta excepcin podra ocurrir, "E" indica una excepcin, y "Z" es un nmero de serie para las excepciones. Por ejemplo "5.0.E.2 "indicara la segunda excepcin para el curso normal para el caso nmero 5 del uso.> 2.0.E1 La imagen elegida no es del tipo JPG. Se le comunicar al usuario con una ventana de aviso y tendr que volver a elegir otra imagen. 1.1.E1 El nombre de la imagen dada no es del tipo JPG. Se le comunicar al usuario con una ventana de aviso y tendr que dar otro nombre o elegir la imagen mediante el browser.
7.3.2.1.8 Prioridad <Indica la prioridad relativa de poner en ejecucin este caso de uso. El esquema de la prioridad usado debe ser igual que el especificado en los requisitos del software.> Muy alta
7.3.2.1.9 Frecuencia de caso de uso <Aqu se estima el nmero de veces que este caso de uso ser realizado por los actores por una cierta unidad de tiempo apropiada.>
Muy a menudo
7.3.2.1.10 Requerimientos especiales <En esta seccin se identifica cualquier requisito adicional, por ejemplo requisitos no funcionales, para el caso del uso que puede necesitar ser tratado durante diseo o la puesta en prctica. stos pueden incluir requisitos de funcionamiento u otras cualidades referente a la calidad.> 1. Internacionalizacin del lenguaje de texto que se muestra. 2. Aplicacin sobre cualquier sistema operativo ( multiplataforma )
7.3.2.1.11 Suposiciones de partida <Aqu se numera cualquier suposicin de partida que fuera hecha en el anlisis que condujo a aceptar este caso del uso en la descripcin del producto > 1. Las imgenes sern 2D y estarn en formato JPG.
7.3.2.1.12
Cuadro resumen del caso de uso visualizar 2D
Actores: Usuario Descripcin: El usuario busca o da el nombre de una imagen 2D en color con extensin JPG. El sistema leer y abrir el fichero permitiendo su visualizacin Precondiciones: Las imgenes son 2D y tienen el formato JPG Poscondiciones: Aparece una pantalla en la que se visualiza la imagen Curso normal: El usuario abre un browser para buscar las imgenes JPG. El usuario busca y elige la imagen a visualizar. El nombre de esta imagen y su localizacin se carga en el programa. Se abre una ventana en que se visualiza la imagen elegida Curso alternativo: El usuario carga directamente el nombre de la imagen. Excepciones: La imagen elegida no es del tipo JPG. El nombre de la imagen dada no es del tipo JPG Inclusiones: Prioridad: Muy alta Frecuencia de uso: Muy a menudo Reglas de negocio: Requerimientos Internacionalizacin del lenguaje de texto que se muestra.
100
especiales: Aplicacin sobre sistemas operativos de Microsoft. Suposiciones de partida: Las imgenes sern de 2D y estarn en formato JPG. Notas y documentos:
7.3.2.2 Caso de uso visualizar 3D
7.3.2.2.2 Descripcin <Este apartado proporciona una breve descripcin de la razn y del resultado de este caso del uso, o una descripcin de alto nivel de la secuencia de acciones y del resultado al ejecutar el caso del uso> El usuario busca o da el nombre de una imagen 3D en escala de grises con extensin PIC. El sistema leer y abrir el fichero permitiendo su visualizacin.
7.3.2.2.3 Precondiciones <Aqu se enumera cualquier actividad que deba ocurrir, o cualquier condicin que deban ser verdaderas, antes de que el caso del uso pueda ser comenzado. Se numera cada condicin previa.> 1. Las imgenes son 3D y tienen el formato PIC. 7.3.2.2.4 Poscondiciones <Se describe el estado del sistema en la conclusin de la ejecucin del caso del uso. Se numera cada postcondition.> 1. Al indicar el nombre de la imagen, aparece una pantalla en la que se visualiza dicha imagen.
101
7.3.2.2.5 Curso de xito <En este apartado se hace una descripcin detallada de cmo acta el sistema ante este caso de uso, en su curso de xito o normal, evitando las bifurcaciones. Esta descripcin se realizar a modo de estados en el que evoluciona el sistema en la realizacin del caso de uso. La enumeracin ser con X.0, donde X es el ID del uso de caso.> 1.0 El usuario abre un browser para buscar las imgenes PIC. 2.0 El usuario busca y elige la imagen a visualizar. 3.0 El nombre de esta imagen y su localizacin se carga en el programa. 4.0 Se abre una ventana en que se visualiza la imagen elegida.
7.3.2.2.6 Curso alternativo <Cursos alternativos y legtimos del uso que pueden ocurrir dentro de este caso de uso. Se indica el curso alternativo, y se describe cualquier diferencia en la secuencia de los pasos que ocurren. Se numera cada curso alternativo en la forma "X.Y ", donde "X" identifica el caso de uso y la Y es un nmero de serie para la alternativa. Por ejemplo, "5.3" indicaran el tercer curso alternativo para el caso nmero 5 del caso de uso.> 1.1 El usuario carga directamente el nombre de la imagen. 7.3.2.2.7 Excepciones <En este apartado se describe cualquier condicin de error anticipada que podra ocurrir durante la ejecucin del caso de uso, y se define cmo el sistema es capaz de responder a estas condiciones. Tambin, se describe cmo el sistema responde si la ejecucin del caso de uso falla por una cierta razn inesperada. Se numera cada curso alternativo en la forma "X.Y.E.Z ", donde "X" identifica el caso del uso, Y indica (0) normal o el curso alternativo (>0) durante los cuales esta excepcin podra ocurrir, "E" indica una excepcin, y "Z" es un nmero de serie para las excepciones. Por ejemplo "5.0.E.2 "indicara la segunda excepcin para el curso normal para el caso nmero 5 del uso.> 2.0.E1 La imagen elegida no es del tipo PIC. Se le comunicar al usuario con una ventana de aviso y tendr que volver a elegir otra imagen.
102
1.1.E1 El nombre de la imagen dada no es del tipo PIC. Se le comunicar al usuario con una ventana de aviso y tendr dar otro nombre o elegirla imagen mediante el browser. 3.0.E1 La imagen no estn en escala de grises. Se producir un error en el procesamiento de la imagen y se le comunicar al usuario. 7.3.2.2.8 Prioridad <Indica la prioridad relativa de poner en ejecucin este caso de uso. El esquema de la prioridad usado debe ser igual que el especificado en los requisitos del software.> Muy alta 7.3.2.2.9 Frecuencia de caso de uso <Aqu se estima el nmero de veces que este caso de uso ser realizado por los actores por una cierta unidad de tiempo apropiada.> Muy a menudo 7.3.2.2.10 Requerimientos especiales <En esta seccin se identifica cualquier requisito adicional, por ejemplo requisitos no funcionales, para el caso del uso que puede necesitar ser tratado durante diseo o la puesta en prctica. stos pueden incluir requisitos de funcionamiento u otras cualidades referente a la calidad.> 1. Internacionalizacin del lenguaje de texto que se muestra. 2. Aplicacin sobre cualquier sistema operativo ( multiplataforma ) 7.3.2.2.11 Suposiciones de partida <Aqu se numera cualquier suposicin de partida que fuera hecha en el anlisis que condujo a aceptar este caso del uso en la descripcin del producto > 1. Las imgenes sern de 3D en escala de grises y estarn en formato PIC.
103
7.3.2.2.12
Cuadro resumen del caso de uso visualizar 3D
Actores: Usuario Descripcin: El usuario busca o da el nombre de una imagen 3D en escala de

grises con extensin PIC. El sistema leer y abrir el fichero permitiendo su visualizacin.
Precondiciones: Las imgenes son 3D y tienen el formato PIC. Poscondiciones: Aparece una pantalla en la que se visualiza la imagen Curso normal: El usuario abre un browser para buscar las imgenes JPG. El usuario busca y elige la imagen a visualizar. El nombre de esta imagen y su localizacin se carga en el programa. Se abre una ventana en que se visualiza la imagen elegida Curso alternativo: El usuario carga directamente el nombre de la imagen. Excepciones: La imagen elegida no es del tipo PIC. El nombre de la imagen dada no es del tipo PIC. La imagen no estn en escala de grises. Se producir un error en el procesamiento de la imagen y se le comunicar al usuario. Inclusiones: Prioridad: Muy alta Frecuencia de uso: Muy a menudo Reglas de negocio: Requerimientos Internacionalizacin del lenguaje de texto que se muestra. especiales: Aplicacin sobre sistemas operativos de Microsoft. Suposiciones de partida: Las imgenes sern de 3D en escala de grises y estarn en formato PIC Notas y documentos:
7.3.2.3 Caso de uso filtrar difusin 2D
104
7.3.2.3.2 Descripcin <Este apartado proporciona una breve descripcin de la razn y del resultado de este caso del uso, o una descripcin de alto nivel de la secuencia de acciones y del resultado al ejecutar el caso del uso> El usuario busca o da el nombre de una imagen 2D en color o en niveles de grises, con extensin JPG. El sistema, tras procesar la imagen mediante filtrados de difusin isotrpica y anisotrpica, genera una imagen filtrada como resultado.
7.3.2.3.3 Precondiciones <Aqu se enumera cualquier actividad que deba ocurrir, o cualquier condicin que deban ser verdaderas, antes de que el caso del uso pueda ser comenzado. Se numera cada condicin previa.> 1. Las imgenes son 2D y tienen el formato JPG.
7.3.2.3.4 Poscondiciones <Se describe el estado del sistema en la conclusin de la ejecucin del caso del uso. Se numera cada postcondition.> 1. Al analizar las imgenes, este caso de uso generar imgenes filtradas mediante difusin isotrpica y anisotrpica que podrn ser visualizadas.
7.3.2.3.5 Curso de xito <En este apartado se hace una descripcin detallada de cmo acta el sistema ante este caso de uso, en su curso de xito o normal, evitando las bifurcaciones. Esta descripcin se realizar a modo de estados en el que evoluciona el sistema en la realizacin del caso de uso. La enumeracin ser con X.0, donde X es el ID del uso de caso.> 1.0 2.0 3.0 El usuario carga las imgenes en un directorio. El usuario inicializa la aplicacin y entrega al Sistema, mediante el GUI, el directorio donde se encuentra la imagen a analizar. El usuario introduce el nombre del fichero donde desea que se guarden los resultados del filtrado.
105
4.0 5.0
El Sistema procesa las imgenes. El usuario espera a que el sistema procese las imgenes.
7.3.2.3.6 Curso alternativo <Cursos alternativos y legtimos del uso que pueden ocurrir dentro de este caso de uso. Se indica el curso alternativo, y se describe cualquier diferencia en la secuencia de los pasos que ocurren. Se numera cada curso alternativo en la forma "X.Y ", donde "X" identifica el caso de uso y la Y es un nmero de serie para la alternativa. Por ejemplo, "5.3" indicaran el tercer curso alternativo para el caso nmero 5 del caso de uso.> 1.1 El usuario indica si desea llevar a cabo el filtrado de las imgenes mediante procesamiento distribudo
7.3.2.3.7 Excepciones <En este apartado se describe cualquier condicin de error anticipada que podra ocurrir durante la ejecucin del caso de uso, y se define cmo el sistema es capaz de responder a estas condiciones. Tambin, se describe cmo el sistema responde si la ejecucin del caso de uso falla por una cierta razn inesperada. Se numera cada curso alternativo en la forma "X.Y.E.Z ", donde "X" identifica el caso del uso, Y indica (0) normal o el curso alternativo (>0) durante los cuales esta excepcin podra ocurrir, "E" indica una excepcin, y "Z" es un nmero de serie para las excepciones. Por ejemplo "5.0.E.2 "indicara la segunda excepcin para el curso normal para el caso nmero 5 del uso.> 2.0.E.1 En el directorio de las imgenes que indica el Usuario no tiene ninguna imagen. Se le mandar mensaje de que el directorio est vaco y no se dejar continuar hasta que elija un directorio con imgenes JPG. 2.1.E.1 El procesamiento distribudo no puede llevarse a cabo. El Usuario recibir un mensaje indicndole lo ocurrido, y se le permitir cambiar esta opcin antes de continuar. 4.0.E.1. No se pasar al procesamiento de las imgenes hasta que no est el directorio de las imgenes y el nombre de fichero de ubicacin de resultados, ambos verificados y correctos.
106
7.3.2.3.8 Prioridad <Indica la prioridad relativa de poner en ejecucin este caso de uso. El esquema de la prioridad usado debe ser igual que el especificado en los requisitos del software.> Alta
7.3.2.3.9 Frecuencia de caso de uso <Aqu se estima el nmero de veces que este caso de uso ser realizado por los actores por una cierta unidad de tiempo apropiada.> A menudo 7.3.2.3.10 Requerimientos especiales <En esta seccin se identifica cualquier requisito adicional, por ejemplo requisitos no funcionales, para el caso del uso que puede necesitar ser tratado durante diseo o la puesta en prctica. stos pueden incluir requisitos de funcionamiento u otras cualidades referente a la calidad.>
1. Internacionalizacin del lenguaje de texto que se muestra. 2. Aplicacin sobre cualquier sistema operativo ( multiplataforma ). 3. El tiempo de procesamiento no estar limitado.
7.3.2.3.11 Suposiciones de partida <Aqu se numera cualquier suposicin de partida que fuera hecha en el anlisis que condujo a aceptar este caso del uso en la descripcin del producto > 1. Las imgenes sern de 2D en escala de grises o en color, y estarn en formato JPG. 7.3.2.3.12 Cuadro resumen del caso de uso filtrar difusin 2D
Actores: Usuario Descripcin: Procesar las imgenes mediante filtrados de difusin isotrpica y anisotrpica, generando una imagen filtrada como resultado
Precondiciones: Las imgenes son 2D y tienen el formato JPG Poscondiciones: Generar imgenes filtradas mediante difusin Curso normal: El usuario carga las imgenes en un directorio, inicializa la aplicacin y entrega al Sistema, mediante el GUI, el directorio donde se encuentra la imagen a analizar y el nombre del fichero donde desea que se guarden los resultados del filtrado. El Sistema procesa las imgenes. El Usuario espera a que el sistema procese las imgenes. Curso alternativo: El usuario tiene la opcin de llevar a cabo el filtrado de las imgenes mediante procesamiento distribudo Excepciones: En el directorio de las imgenes que indica el Usuario no tiene ninguna imagen. El procesamiento distribudo no puede llevarse a cabo. Inclusiones: Prioridad: Alta. Es una de las funcionalidades principales del programa Frecuencia de uso: A menudo Reglas de negocio: Requerimientos El tiempo de procesamiento no estar limitado. especiales: Suposiciones de partida: Las imgenes sern de 2D en escala de grises o en color, y estarn en formato JPG. Notas y documentos:
7.3.2.4 Caso de uso filtrar difusin 3D
7.3.2.4.1 Actor <Un actor es la persona o entidad externa al sistema de software que trabaja con el sistema y realiza casos del uso para lograr tareas. Diversos agentes corresponden a menudo a diversas clases del usuario, o papeles, definiendo la comunidad del cliente que utilizar el producto. Nombre del actor(s) que realizar este caso del uso.> Usuario 7.3.2.4.2 Descripcin <Este apartado proporciona una breve descripcin de la razn y del resultado de este caso del uso, o una descripcin de alto nivel de la secuencia de acciones y del resultado al ejecutar el caso del uso>
108
El usuario busca o da el nombre de una imagen 3D en niveles de grises, con extensin PIC. El sistema, tras procesar la imagen mediante filtrados de difusin isotrpica y anisotrpica, genera una imagen filtrada como resultado.
7.3.2.4.3 Precondiciones <Aqu se enumera cualquier actividad que deba ocurrir, o cualquier condicin que deban ser verdaderas, antes de que el caso del uso pueda ser comenzado. Se numera cada condicin previa.> 1. Las imgenes son 3D en escala de grises y tienen el formato PIC. 7.3.2.4.4 Poscondiciones <Se describe el estado del sistema en la conclusin de la ejecucin del caso del uso. Se numera cada postcondition.> 1. Al analizar las imgenes, este caso de uso generar imgenes filtradas mediante difusin isotrpica y anisotrpica que podrn ser visualizadas. 7.3.2.4.5 Curso de xito <En este apartado se hace una descripcin detallada de cmo acta el sistema ante este caso de uso, en su curso de xito o normal, evitando las bifurcaciones. Esta descripcin se realizar a modo de estados en el que evoluciona el sistema en la realizacin del caso de uso. La enumeracin ser con X.0, donde X es el ID del uso de caso.> 1.0 2.0 El usuario carga las imgenes en un directorio. El usuario inicializa la aplicacin y entrega al Sistema, mediante el GUI, el directorio donde se encuentra la imagen a analizar. El usuario introduce el nombre del fichero donde desea que se guarden los resultados del filtrado. El Sistema procesa las imgenes. El usuario espera a que el sistema procese las imgenes.
3.0
4.0 5.0
7.3.2.4.6 Curso alternativo <Cursos alternativos y legtimos del uso que pueden ocurrir dentro de este caso de uso. Se indica el curso alternativo, y se describe cualquier diferencia en la
secuencia de los pasos que ocurren. Se numera cada curso alternativo en la forma "X.Y ", donde "X" identifica el caso de uso y la Y es un nmero de serie para la alternativa. Por ejemplo, "5.3" indicaran el tercer curso alternativo para el caso nmero 5 del caso de uso.> 1.1 El usuario indica si desea llevar a cabo el filtrado de las imgenes mediante procesamiento distribudo
7.3.2.4.7 Excepciones <En este apartado se describe cualquier condicin de error anticipada que podra ocurrir durante la ejecucin del caso de uso, y se define cmo el sistema es capaz de responder a estas condiciones. Tambin, se describe cmo el sistema responde si la ejecucin del caso de uso falla por una cierta razn inesperada. Se numera cada curso alternativo en la forma "X.Y.E.Z ", donde "X" identifica el caso del uso, Y indica (0) normal o el curso alternativo (>0) durante los cuales esta excepcin podra ocurrir, "E" indica una excepcin, y "Z" es un nmero de serie para las excepciones. Por ejemplo "5.0.E.2 "indicara la segunda excepcin para el curso normal para el caso nmero 5 del uso.> 2.0.E.1 En el directorio de las imgenes que indica el Usuario no tiene ninguna imagen. Se le mandar mensaje de que el directorio est vaco y no se dejar continuar hasta que elija un directorio con imgenes PIC. 2.1.E.1 El procesamiento distribudo no puede llevarse a cabo. El Usuario recibir un mensaje indicndole lo ocurrido, y se le permitir cambiar esta opcin antes de continuar. 4.0.E.1. No se pasar al procesamiento de las imgenes hasta que no est el directorio de las imgenes y el nombre de fichero de ubicacin de resultados, ambos verificados y correctos. 7.3.2.4.8 Prioridad <Indica la prioridad relativa de poner en ejecucin este caso de uso. El esquema de la prioridad usado debe ser igual que el especificado en los requisitos del software.> Alta 7.3.2.4.9 Frecuencia de caso de uso <Aqu se estima el nmero de veces que este caso de uso ser realizado por los actores por una cierta unidad de tiempo apropiada.>
110
A menudo
7.3.2.4.10 Requerimientos especiales <En esta seccin se identifica cualquier requisito adicional, por ejemplo requisitos no funcionales, para el caso del uso que puede necesitar ser tratado durante diseo o la puesta en prctica. stos pueden incluir requisitos de funcionamiento u otras cualidades referente a la calidad.> 1. Internacionalizacin del lenguaje de texto que se muestra. 2. Aplicacin sobre cualquier sistema operativo ( multiplataforma ). 3. El tiempo de procesamiento no estar limitado.
7.3.2.4.11 Suposiciones de partida <Aqu se numera cualquier suposicin de partida que fuera hecha en el anlisis que condujo a aceptar este caso del uso en la descripcin del producto > 1. Las imgenes sern de 3D en escala de grises, y estarn en formato PIC.
7.3.2.4.12
Cuadro resumen del caso de uso filtrar difusin 3D
Actores: Usuario Descripcin: Procesar las imgenes mediante filtrados de difusin isotrpica y anisotrpica, generando una imagen filtrada como resultado Precondiciones: Las imgenes son 3D en escala de grises y tienen el formato PIC Poscondiciones: Generar imgenes filtradas mediante difusin Curso normal: El usuario carga la imagen en un directorio, inicializa la aplicacin y entrega al Sistema, mediante el GUI, el directorio donde se encuentran la imagen a analizar y el nombre del fichero donde desea que se guarden los resultados del filtrado. El Sistema procesa la imagen. El Usuario espera a que el sistema procese la imagen. Curso alternativo: El usuario tiene la opcin de llevar a cabo el filtrado de las
imgenes mediante procesamiento distribudo Excepciones: En el directorio de las imgenes que indica el Usuario no tiene ninguna imagen. El procesamiento distribudo no puede llevarse a cabo. Inclusiones: Prioridad: Alta. Es una de las funcionalidades principales del programa Frecuencia de uso: Alta Reglas de negocio: Requerimientos El tiempo de procesamiento no estar limitado. especiales: Suposiciones de partida: Las imgenes sern 3D en niveles de grises, y estarn en formato JPG Notas y documentos:
7.4 Creacin de la aplicacin mediante Rational Rose

Una vez completados todos los documentos necesarios para llevar a cabo la descripcin y planificacin de nuestro proyecto, pero antes de implementar el cdigo propiamente dicho, crearemos un modelo de la aplicacin mediante Rational Rose. La herramienta Rational Rose nos permite plasmar visualmente todas las especificaciones de nuestra aplicacin siguiendo el ciclo de desarrollo del Proceso Unificado (UP). De esta manera, crearemos todos los diagramas necesarios especificados dentro del modelado UML, como los diagramas de clases, de secuencia, de colaboracin, etc. Tambin definiremos los elementos que componen la aplicacin (objetos), as como las relaciones entre ellos. Despus de esto, Rational Rose nos permite incluso generar la base del cdigo de nuestra aplicacin a partir del modelo creado. En ese momento ya estaremos listos para pasar al desarrollo de ese cdigo en el lenguaje de programacin ms adecuado a nuestras necesidades (en este caso C++).
7.4.1 Creacin del proyecto De ahora en adelante, se tiene como objetivo mostrar los pasos a seguir, dentro de la ingeniera del software, para la creacin de nuestra aplicacin mediante Rational Rose. Lo primero que hacemos es ejecutar el Rational Rose y abrir un nuevo proyecto siguiendo los pasos del proceso unificado: 1. Abrimos Rational Rose 2000, y empleamos el navegador de proyectos. 2. Leer los detalle de cada uno de ellos.
112
3. Seleccionamos un proyecto de UP. 4. Salvamos el proyecto como difusion2D3D.mdl. 5. Para cualquier duda, utilizamos la tecla F1 .
Figura 7.6 : Seleccionar nuevo proyecto
7.4.2 Creacin de casos de uso Observamos que ha aparecido en el margen izquierdo el esquema tpico del UP (casos de uso, vista lgica, vista de componente y vista de desarrollo). Desplegamos el diagrama principal de casos de uso y entramos dentro del paquete de casos de uso del modelo. Rellenamos los casos de uso empleados en nuestra aplicacin siguiendo los siguientes pasos: 6. Empleamos las herramientas que aparecen en el margen izquierdo. 7. Hacemos lo mismo con la notacin del caso de uso y de la asociacin. 8. Trabajamos con el men de contexto (botn derecho del ratn). 9. Documentamos, brevemente, las caractersticas principales del caso de uso y el rol del actor.
Figura 7.7 : Creacin de casos de uso
7.4.3 Creacin del diagrama de clases del modelo de anlisis El siguiente paso se dar en la vista lgica. Desplegamos la carpeta de anlisis del modelo. Generamos un diagrama de clases de modelo de anlisis: 9. "Vista lgica -> Modelo del Anlisis". 10. Men contexto, crear un diagrama de clases. Empleando los artefacto de generacin del modelo de anlisis, rellenamos el diagrama de clases de objetos del dominio. Hay que tener en cuenta que stas son clases conceptuales, no son, de momento, clases software. 11. Insertamos las clases conceptuales del dominio. 12. Creamos clases nuevas como FiltradoDifusion2D o Visualizacion2D. 13. Emplear los mens de contexto para dotarles de sus atributos y operaciones.
114
Figura 7.8 : Modelo de anlisis
7.4.4 Creacin del diagrama de secuencia El siguiente paso ser desplegar la vista de diseo. Sobre esta carpeta creamos un diagrama de secuencia al que llamaremos "SecuenciaDifusion2D3D". Empleando las herramientas insertamos objetos y mensajes. Deben ser instancias, con nombre o sin ella, de las clases conceptuales, anteriormente definida en el diagrama de clases de la etapa de anlisis, y de los actores definidos en el caso de uso. 14. En la carpeta de diseo del modelo insertamos ( new ) un diagrama de secuencia. Lo nombramos como "SecuenciaDifusion2D3D". 15. En la pizarra incluimos el actor "Usuario" y las clases conceptuales FiltradoDifusion2D", "Visualizar2D", etc. Para tal fin, insertamos un objeto y con el men de contexto entramos en las especificaciones ( tambin podemos hacer doble clic ). Posteriormente seleccionamos el tipo de clase y el nombre que damos a la instancia. 16. Aadimos los mensajes, que son funciones miembros de la clase que recibe el mensaje. Los nombres de los mensajes ya se definieron en las clases conceptuales. Bien empleando el men de contexto o con doble clic, aparecer las propuestas de nombres de mensajes definido en la etapa de anlisis.
115
Figura 7.9 : Diagrama de secuencia En el procedimiento UP no se es tan lineal como aqu se est presentado el proceso de AOO/D. Existen realimentaciones entre el modelo de las clases conceptuales con el diagrama de secuencias.
7.4.5 Creacin del diagrama de clases del diseo El siguiente paso es la construccin del diagrama de clases del diseo. Las primeras candidatas sern las clases conceptuales que pueden ser propuestas a ser clases software. Creamos un diagrama de clases desde la carpeta de diseo del modelo. Con los iconos existentes en el margen izquierdo de la pizarra, colocamos las clases anteriormente definidas, convirtindolas de conceptuales a software. 17. En la carpeta de diseo del modelo insertar ( new ) un diagrama de clases.Lo nombramos como "ClasesDifusion2D3D". 18. En la pizarra incluimos las clases conceptuales creadas anteriormente. 19. Establecemos asociaciones entre las clases de entre las distintas que ofrece UML.
116
Figura 7.10 : Diagrama de clases
7.4.6 Generacin de cdigo mediante Rational Rose Alcanzado este nivel ya es posible pasar a cdigo. Primero verificamos que el modelo generado es correcto. En el men principal desplegamos herramientas y seleccionamos verificar modelo. Esta accin provoca que el Rational Rose analice la integridad del modelo y genere un archivo log que reporta los fallos encontrados, si los hubiera. Una vez testeado el modelo pasamos a la conversin a cdigo C++ con plataforma Visual C++. Entramos en el men principal y seleccionamos "Visual C++ -> herramienta de seleccin de componentes". Aadimos un nuevo componente y seleccionamos un proyecto de Visual C++: 20. Verificamos el modelo: "Tools - > Check Model". 21. Generamos el proyecto de Visual C++: "Tools Component Assigment Tool". 22. Seleccionamos VC++. 23. En la vista de componentes creamos un nuevo componente Visual C++. -> Visual C++ ->
117
24. Hacemos doble clic sobre el icono de proyecto. Aparecer el wizard de Visual C++. 25. Seleccionamos un proyecto de consola de 32bits y le nombramos como "Difusion2D3D.dsw". 26. Hemos vinculado el modelo de Rational Rose con el proyecto "Difusion2D3D.dsw".
Figura 7.11 : Generacin del proyecto de Visual C++
118
Figura 7.12 : Seleccin del tipo de proyecto
Creado el proyecto aadimos las clases creadas anteriormente. Desde el men principal seleccionamos "Visual C++ -> actualizar cdigo" y seleccionamos el proyecto. 27. Seleccionamos el proyecto definido de Visual C++: "Tools > Visual C++ > Update Code". 28. Seleccionamos la componente del proyecto. 29. Seleccionamos las clases para el proyecto creadas anteriormente. 30. Validamos las clases asignadas al proyecto. 31. Al finalizar, Rational Rose nos da un informe de los errores y avisos en la conversin.
119
Figura 7.13 : Seleccin de clases para el proyecto
Figura 7.14 : Validacin de clases

Figura 7.15 :Informe de errores y avisos en la conversin
Para terminar, aadimos al proyecto el fichero fuente "vistaPrincipalDifusion2D3D.cpp". Ahora podemos pasar a rellenar el cdigo de las funciones miembros de las clases creadas 7.4.7 Ingeniera inversa Una vez se ha llevado a cabo la generacin de cdigo mediante Rational Rose, pasaramos a implementar el cdigo en si mismo. Durante este proceso, las clases creadas a priori en Rational Rose pueden verse modificadas, alteradas, o incluso pueden aparecer clases nuevas, segn nuestras necesidades. Aqu es donde entra en escena la ingeniera inversa. sta se emplea para actualizar el modelo UML creado en Rational Rose cuando ha quedado desfasado como consecuencia de la implementacin del cdigo de nuestra aplicacin. Primero se configurar el Rational Rose y luego se realizar la ingeniera inversa sobre la aplicacin ya existente.
121
7.4.7.1 Configuracin de Rational Rose: Visual C++ Add-in Para configurar Rational Rose con vistas a su empleo como herramienta de ingeniera inversa debemos sguir los siguientes pasos: 1. Abrimos Rational Rose 2000, sin utilizar el navegador de proyectos (pulsamos el botn "cancelar"). 2. Si Visual C++ no est disponible, lo seleccionamos en el men de "Addin".
Figura 7.16 : Men Add-in Manager
3. Seleccionamos el men de "Tools -> Options -> Notation". 4. En el campo "Default Language" seleccionamos VC++. 5. Hacemos click el botn "Apply" para que haga efecto.
122
Figura 7.17 : Men Tools -> Options -> Notation
6. Seleccionar el menu de "Tools -> Options -> Diagram" 7. Seleccionar "Label" en el campo "Stereotype Display field". 8. No seleccionar "Focus of control".
123
Figura 7.18 : Men Tools -> Options -> Diagram
7.4.7.2 Ingeniera inversa con una aplicacin Una vez configurado, podemos llevar a cabo la ingeniera inversa con Rational Rose. Para ello, inicializamos la aplicacin en el Rational Rose y seguiumos los siguientes pasos: 1. Creamos un nuevo modelo de Rational Rose, sin emplear el wizard de proyecto. 2. Seleccionamos la herramienta "Tools -> Visual C++ -> Update Model from Code".
124
3. Activamos la opcin "Add a VC++ Component".
Figura 7.19 : Creacin de un nuevo modelo
4. Seleccionamos la pestaa "Existing". 5. Navegamos hasta encontrar la carpeta del proyecto de Visual C++, donde se ubica el fichero *.dsw y el cdigo. 6. Seleccionamos el fichero del proyecto (*.dsw) 7. Aceptamos el nombre del proyecto existente. 8. Pulsamos fin.
125
Figura 7.20 : Seleccin del fichero del proyecto
126
Figura 7.21 : Finalizacin del proceso
9. Pulsamos cerrar para acabar la conversin de C++ a UML.
Figura 7.22 : Conversin finalizada

Rational Rose aade las clases a un paquete que llama ingeniera inversa (Reverse Engineered). El diagrama de clases de la vista lgica habr cambiado. 10. Al pulsar + en la carpeta de la vista lgica aparecer el rbol del paquete. 11. Continuando con la expansin de la carpeta de ingeniera inversa, aparecer la carpeta del proyecto. 12. Se han creado las clases y el diagrama de clases.
Figura 7.23 : Nuevo diagrama de clases
7.5 Implementacin del cdigo

En este punto ya estamos listos para llevar a cabo el desarrollo del cdigo de nuestra aplicacin. Este cdigo se implementar en C++ con ayuda de las libreras de VTK.
128
7.5.1 Descripcin de las clases empleadas en la aplicacin Mediante el estudio de la visin y alcance, los casos de uso, etc, del proyecto, y gracias a la herramienta Rational Rose, hemos establecido las clases del programa difusin 2D3D. El programa ha quedado dividido en cinco clases, como vemos en la figura 7.24 :
Figura 7.24: Clases de difusin2D3D
7.5.1.1 Clase visualizacin2D La clase visualizacin2D, como su nombre indica, es la encargada de llevar a cabo la visualizacin de imgenes en dos dimensiones a partir de archivos con formato JPG. Esta clase consta de tres operaciones y un atributo:
Figura 7.25: Clase visualizacin2D
Las funciones setNombreFich(const char file2) y getNombreFich( ) sirven para indicar y obtener respectivamente, el nombre del archivo de imagen JPG que se quiere visualizar ( el atributo nombreFich). Cuando se desea llevar a cabo la visualizacin se utiliza la funcin visualizar2D(const char*).
129
El fichero de cabecera de esta clase, cuya base fue creada con Rational Rose, es el siguiente (visualizacion2D.h): /******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation #if defined (_MSC_VER) && (_MSC_VER >= 1000) #pragma once #endif #ifndef _INC_VISUALIZACION2D_408681C30196_INCLUDED #define _INC_VISUALIZACION2D_408681C30196_INCLUDED //##ModelId=416F9F9C0203 class visualizacion2D { //##ModelId=416F9F9C0204 const char* nombreFich; public: //##ModelId=416F9F9C0209 int visualizar2D(const char*); //##ModelId=416F9F9C0207 void setNombreFich(const char*file2) { nombreFich = file2; } //##ModelId=416F9F9C0205 const char* getNombreFich(void) { return (nombreFich); } }; #endif /* _INC_VISUALIZAR2D_408681C30196_INCLUDED */ /*******************************************************************/
El fichero fuente tambin se incluye a continuacin (visualizacion2D.cpp): /******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation //#include "stdafx.h"
#include "visualizacion2D.h" #include "vtkRenderer.h" #include "vtkRenderWindow.h" #include "vtkJPEGReader.h" #include "vtkRenderWindowInteractor.h" #include "vtkImageMapper.h" #include "vtkActor2D.h" #include "vtkImageData.h" #define ERROR_APERTURA_JPG -1
//##ModelId=408682020399 visualizacion2D::visualizar2D(const char*nombreFich) {
//Creamos el renderizador, la ventana de renderizacin y el interactor con la ventana: vtkRenderer *aRenderer = vtkRenderer::New(); vtkRenderWindow *renWin = vtkRenderWindow::New(); renWin->AddRenderer(aRenderer); vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New(); iren->SetRenderWindow(renWin); //Creamos el JPEGReader y comprobamos que nombreFich es el nombre de un //fichero .jpg : vtkJPEGReader *reader = vtkJPEGReader::New(); if (!reader->CanReadFile(nombreFich)) return (ERROR_APERTURA_JPG); reader->SetFileName(nombreFich); reader->Update();
//Hallamos la dimensin en pixels de la imagen: int dim[2]; reader-> GetOutput()->GetDimensions(dim); //Creamos el mapper y conectamos su entrada con la salida del reader: vtkImageMapper *mapper = vtkImageMapper::New();
mapper->SetInput(reader->GetOutput()); mapper->SetColorWindow(256); mapper->SetColorLevel(128); //Creamos el actor y le asignamos el mapper: vtkActor2D *actor = vtkActor2D::New(); actor->SetMapper(mapper); //Asignamos el actor al renderer: aRenderer->AddActor(actor);
//Establecemos parmetros de la visualizacin: aRenderer->SetBackground(1,1,1); renWin->SetSize(dim[0]+1,dim[1]+1);
//Comenzamos la renderizacin: iren->Initialize(); iren->Start();
//Liberamos los objetos creados: iren->Delete(); mapper->Delete(); actor->Delete(); renWin->Delete(); aRenderer->Delete(); return (0); } /*******************************************************************/
7.5.1.2 Clase visualizacin3D La clase visualizacin3D, como su nombre indica, es la encargada de llevar a cabo la visualizacin de imgenes en tres dimensiones a partir de archivos con formato PIC. Esta clase consta de siete operaciones y tres atributos:
Figura 7.25: Clase visualizacin3D
Las funciones setNombreFich(const char *file2) y getNombreFich( ) sirven para indicar y obtener respectivamente, el nombre del archivo de imagen PIC que se quiere visualizar ( el atributo nombreFich). En este caso tambin es necesario indicar el nmero de rodajas 2D que deseamos que el programa utilice para crear la imagen 3D. Esto se hace mediante las funciones setPrimerCorte(int prim), getPrimerCorte( ), setUltimoCorte(int ult) y getUltimoCorte( ). Finalmente, cuando se desea llevar a cabo la visualizacin se utiliza la funcin visualizar3D(const char*, int, int). El fichero de cabecera de esta clase, cuya base fue creada con Rational Rose, resulta el siguiente (visualizacion3D.h): /*******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation #if defined (_MSC_VER) && (_MSC_VER >= 1000) #pragma once #endif #ifndef _INC_VISUALIZACION3D_4086837102DE_INCLUDED #define _INC_VISUALIZACION3D_4086837102DE_INCLUDED //##ModelId=416F9F9C01A7 class visualizacion3D { //##ModelId=416F9F9C01C5 const char* nombreFich; int primerCorte, ultimoCorte; public:
//##ModelId=416F9F9C01EB int visualizar3D(const char*,int,int); //##ModelId=416F9F9C01E9 void setNombreFich(const char*file2) { nombreFich = file2; } //##ModelId=416F9F9C01E7 const char* getNombreFich(void) { return (nombreFich); } //##ModelId=416F9F9C01E5 void setPrimerCorte(int prim) { primerCorte = prim; } //##ModelId=416F9F9C01D7 void setUltimoCorte(int ult) { ultimoCorte = ult; } //##ModelId=416F9F9C01D5 int getPrimerCorte(void) { return (primerCorte); } //##ModelId=416F9F9C01C6 int getUltimoCorte(void) { return (ultimoCorte); } }; #endif /* _INC_VISUALIZAR3D_4086837102DE_INCLUDED */ /*******************************************************************/ El fichero fuente (visualizacion3D.cpp):
134
de
esta
clase
es
el
includo
continuacin
/******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation //#include "stdafx.h" #include "visualizacion3D.h" #include "vtkRenderer.h" #include "vtkRenderWindow.h" #include "vtkRenderWindowInteractor.h" #include "vtkImageReader.h" #include "vtkContourFilter.h" #include "vtkSmoothPolyDataFilter.h" #include "vtkPolyDataNormals.h" #include "vtkPolyDataMapper.h" #include "vtkActor.h" #include "vtkOutlineFilter.h" #include "vtkCamera.h" #include "vtkProperty.h" #include "vtkMergePoints.h" #define BIORAD_HEADER_LENGTH 76 #define BYTE_TO_WORD(lsb,msb) (((unsigned char) lsb) + (((unsigned char) msb) << 8)) #define ERROR_APERTURA_PIC -1 #define ERROR_NUMERO_COLUMNAS -2 #define ERROR_NUMERO_FILAS -3 #define ERROR_NUMERO_CORTES -4 //##ModelId=4086838B0242 visualizacion3D::visualizar3D(const char* nombreFich,int primerCorte,int ultimoCorte) {
//Creamos el renderer, renderwindow y rederwindowinteractor: vtkRenderer *aRenderer = vtkRenderer::New(); vtkRenderWindow *renWin = vtkRenderWindow::New(); renWin->AddRenderer(aRenderer); vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New(); iren->SetRenderWindow(renWin); int nx, ny, nz; unsigned char *head2 = new unsigned char[76];
135
//Apertura del fichero.pic y comprobacin de que nombreFich contiene el nombre de //un fichero .pic FILE *head1; head1 = fopen(nombreFich,"rb"); if (head1 == NULL) return (ERROR_APERTURA_PIC);
//Lectura de la cabecera del fichero PIC BIORAD fread(head2,sizeof(unsigned char),BIORAD_HEADER_LENGTH,head1); nx = BYTE_TO_WORD(head2[0], head2[1]); ny = BYTE_TO_WORD(head2[2], head2[3]); nz = BYTE_TO_WORD(head2[4], head2[5]); fclose(head1); //Verificaciones if ( nx <= 0 ) return (ERROR_NUMERO_COLUMNAS); if ( ny <= 0 ) return (ERROR_NUMERO_FILAS); if ( nz <= 0 ) return (-4);
nx = nx -1; ny = ny -1; nz = nz -1;
//Creamos el ImageReader: vtkImageReader *reader = vtkImageReader::New(); reader->SetFileName(nombreFich); reader->SetFileDimensionality(3); reader->SetDataExtent(0, nx, 0, ny, 0, nz); reader->SetDataVOI(0, nx, 0, ny, primerCorte, ultimoCorte); reader->SetDataOrigin(0, 0, 0); reader->SetDataScalarTypeToUnsignedChar(); reader->SetDataSpacing(1.0, 1.0, 0.2); reader->SetHeaderSize(76);
136
//Aplicamos los filtros, mappers y actores necesarios: vtkContourFilter *skinExtractor = vtkContourFilter::New(); skinExtractor->SetInput((vtkDataSet *) reader->GetOutput()); skinExtractor->SetValue(0, 254); vtkSmoothPolyDataFilter *smooth = vtkSmoothPolyDataFilter::New(); smooth->SetInput(skinExtractor->GetOutput()); smooth->SetNumberOfIterations(50); smooth->BoundarySmoothingOn(); smooth->SetFeatureAngle(120); smooth->SetEdgeAngle(90); smooth->SetRelaxationFactor(.025); vtkPolyDataNormals *skinNormals = vtkPolyDataNormals::New(); skinNormals->SetInput(smooth->GetOutput()); skinNormals->SetFeatureAngle(60.0); vtkPolyDataMapper *skinMapper = vtkPolyDataMapper::New(); skinMapper->SetInput(skinNormals->GetOutput()); skinMapper->ScalarVisibilityOff(); vtkActor *skin = vtkActor::New(); skin->SetMapper(skinMapper); vtkOutlineFilter *outlineData = vtkOutlineFilter::New(); outlineData->SetInput((vtkDataSet *) reader->GetOutput()); vtkPolyDataMapper *mapOutline = vtkPolyDataMapper::New(); mapOutline->SetInput(outlineData->GetOutput()); vtkActor *outline = vtkActor::New(); outline->SetMapper(mapOutline); outline->GetProperty()->SetColor(0,0,0); //Creamos la cmara y establecemos sus parmetros: vtkCamera *aCamera = vtkCamera::New(); aCamera->SetViewUp (0, 0, -1); aCamera->SetPosition (0, 1, 0); aCamera->SetFocalPoint (0, 0, 0); aCamera->ComputeViewPlaneNormal();
//Establecemos los parmetros del renderer: aRenderer->AddActor(outline); aRenderer->AddActor(skin);

aRenderer->SetActiveCamera(aCamera); aRenderer->ResetCamera (); aCamera->Dolly(1.5); aRenderer->SetBackground(1,1,1); renWin->SetSize(512, 512); aRenderer->ResetCameraClippingRange (); // Comenzamos la renderizacin: iren->Initialize(); iren->Start(); //Liberamos los objetos creados: smooth->Delete(); skinExtractor->Delete(); skinNormals->Delete(); skinMapper->Delete(); skin->Delete(); outlineData->Delete(); mapOutline->Delete(); outline->Delete(); aCamera->Delete(); iren->Delete(); renWin->Delete(); aRenderer->Delete(); return 0; } /******************************************************************/
7.5.1.3 Clase filtradoDifusin2D La clase filtradoDifusin2D, como su nombre indica, es la encargada de llevar a cabo el filtrado de difusin y la posterior visualizacin de imgenes en dos dimensiones a partir de archivos con formato JPG. Esta clase consta de nueve operaciones y un cuatro atributos:
138
Figura 7.26: Clase filtradodifusin2D
Esta clase incluye las mismas funciones que la clase visualizacin2D para obtener el nombre del archivo que contiene la imagen JPG en dos dimensiones. Adems, incluye las funciones necesarias para proporcionar al programa los parmetros necesarios para llevar a cabo el filtrado de difusin. Estos parmetros son factor de difusin, nmero de iteraciones y umbral de difusin. Para llevar a cabo el filtrado y visualizacin del resultado se utiliza la funcin filtrarDifusion2D(const char*). El fichero de cabecera de esta clase, cuya base fue creada con Rational Rose, resulta el siguiente (filtradoDifusion2D.h): /*******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation #if defined (_MSC_VER) && (_MSC_VER >= 1000) #pragma once #endif #ifndef _INC_FILTRADODIFUSION2D_408681C30196_INCLUDED #define _INC_FILTRADODIFUSION2D_408681C30196_INCLUDED //##ModelId=416F9F9C0290 class filtradoDifusion2D { //##ModelId=416F9F9C0292 const char* nombreFich; int nIteraciones; float umbralDifusion, factorDifusion;
139
public: //##ModelId=416F9F9C02A3 int filtrarDifusion2D(const char*); //##ModelId=416F9F9C02A1 void setNombreFich(const char*file2) { nombreFich = file2; } //##ModelId=416F9F9C029F const char* getNombreFich(void) { return (nombreFich); } //##ModelId=416F9F9C029D void setIteraciones ( int nIter = 1) { nIteraciones = nIter;} //##ModelId=416F9F9C029B int getIteraciones ( void) { return(nIteraciones);} //##ModelId=416F9F9C0299 void setFactorDifusion ( float factorDif ) { factorDifusion = factorDif;} //##ModelId=416F9F9C0297 float getFactorDifusion ( void) { return(factorDifusion);} //##ModelId=416F9F9C0295 void setUmbralDifusion ( float umbralDif ) { umbralDifusion = umbralDif;} //##ModelId=416F9F9C0293 float getUmbralDifusion ( void) { return(umbralDifusion);} }; #endif /* _INC_VISUALIZAR2D_408681C30196_INCLUDED */ /******************************************************************/
140
El fichero fuente (filtradoDifusion2D.cpp):
de
esta
clase
se
incluye
continuacin
/******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation //#include "stdafx.h" #include "filtradoDifusion2D.h" #include "vtkRenderer.h" #include "vtkRenderWindow.h" #include "vtkJPEGReader.h" #include "vtkRenderWindowInteractor.h" #include "vtkImageMapper.h" #include "vtkActor2D.h" #include "vtkImageAnisotropicDiffusion2D.h" #include "vtkImageData.h" #include "vtkJPEGWriter.h" #define ERROR_APERTURA_JPG -1
//##ModelId=408682020399 filtradoDifusion2D::filtrarDifusion2D(const char*nombreFich) {
//Creamos el renderizador,la ventana de renderizacin y el interactor con la ventana vtkRenderer *aRenderer = vtkRenderer::New(); vtkRenderWindow *renWin = vtkRenderWindow::New(); renWin->AddRenderer(aRenderer); vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New(); iren->SetRenderWindow(renWin); //Creamos el JPEGReader: vtkJPEGReader *reader = vtkJPEGReader::New(); if (!reader->CanReadFile(nombreFich)) return (ERROR_APERTURA_JPG); reader->SetFileName(nombreFich); reader->Update(); //Hallamos la dimensin en pixels de la imagen:
141
int dim[2]; reader-> GetOutput()->GetDimensions(dim);
// Creamos el filtro de difusin anisotrpica y conectamos su entrada con la salida del //reader: vtkImageAnisotropicDiffusion2D *difusor = vtkImageAnisotropicDiffusion2D::New(); difusor->SetInput(reader->GetOutput()); difusor->CornersOn(); difusor->EdgesOn(); difusor->FacesOn(); difusor->GradientMagnitudeThresholdOn(); difusor->SetNumberOfIterations(nIteraciones); difusor->SetDiffusionThreshold(umbralDifusion); difusor->SetDiffusionFactor(factorDifusion); difusor->Update(); // Guardamos la imagen filtrada: vtkJPEGWriter *imgDifusion=vtkJPEGWriter::New(); imgDifusion->SetInput(difusor->GetOutput()); imgDifusion>SetFileName("D:\\iberzal\\Difusion2D3D\\Codigo\\visualizacion2D3D_0.2\\R esultados\\filtrado2D.jpg"); imgDifusion->Write(); //Creamos el mapper y conectamos su entrada con la salida del filtro: vtkImageMapper *mapper = vtkImageMapper::New(); mapper->SetInput(difusor->GetOutput()); mapper->SetColorWindow(256); mapper->SetColorLevel(128); //Creamos el actor y le asignamos el mapper vtkActor2D *actor = vtkActor2D::New(); actor->SetMapper(mapper); //Asignamos el actor al renderer
142
aRenderer->AddActor(actor);
//Establecemos parmetros de la visualizacin aRenderer->SetBackground(1,1,1); renWin->SetSize(dim[0]+1,dim[1]+1); iren->Initialize(); iren->Start(); //Liberamos los objetos creados: iren->Delete(); mapper->Delete(); actor->Delete(); renWin->Delete(); aRenderer->Delete(); difusor->Delete(); return (0); } /*******************************************************************/
7.5.1.4 Clase filtradoDifusin3D La clase filtradoDifusin3D, como su nombre indica, es la encargada de llevar a cabo el filtrado de difusin y la posterior visualizacin de imgenes en tres dimensiones a partir de archivos con formato PIC. Esta clase consta de trece operaciones y un seis atributos:
143
Figura 7.27: Clase filtradoDifusin3D
Esta clase incluye las mismas funciones que la clase visualizacin3D para obtener el nombre del archivo que contiene la imagen PIC, as como para establecer el numero de rodajas que tomar el programa para crear la imagen 3D. Adems, incluye las funciones necesarias para proporcionar al programa los parmetros necesarios para llevar a cabo el filtrado de difusin. Estos parmetros son factor de difusin, nmero de iteraciones y umbral de difusin. Para llevar a cabo el filtrado y visualizacin del resultado se utiliza la funcin filtrarDifusion3D(const char*, int, int). El fichero de cabecera de esta clase, cuya base fue creada con Rational Rose, resulta el siguiente (filtradoDifusion3D.h): /*******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation #if defined (_MSC_VER) && (_MSC_VER >= 1000) #pragma once #endif #ifndef _INC_FILTRADODIFUSION3D_4086837102DE_INCLUDED #define _INC_FILTRADODIFUSION3D_4086837102DE_INCLUDED //##ModelId=416F9F9C0242 class filtradoDifusion3D {
//##ModelId=416F9F9C0251 const char* nombreFich; int primerCorte, ultimoCorte; //##ModelId=416F9F9C0243 int nIteraciones; float umbralDifusion, factorDifusion; public: //##ModelId=416F9F9C026A int filtrarDifusion3D(const char*,int,int); //##ModelId=416F9F9C0268 void setNombreFich(const char*file2) { nombreFich = file2; } //##ModelId=416F9F9C0266 const char* getNombreFich(void) { return (nombreFich); } //##ModelId=416F9F9C0264 void setPrimerCorte(int prim) { primerCorte = prim; } //##ModelId=416F9F9C0262 void setUltimoCorte(int ult) { ultimoCorte = ult; } //##ModelId=416F9F9C0260 int getPrimerCorte(void) { return (primerCorte); } //##ModelId=416F9F9C025E int getUltimoCorte(void) { return (ultimoCorte); }
//##ModelId=416F9F9C025C void setIteraciones ( int nIter = 1) { nIteraciones = nIter;} //##ModelId=416F9F9C025A int getIteraciones ( void) { return(nIteraciones);} //##ModelId=416F9F9C0258 void setFactorDifusion ( float factorDif ) { factorDifusion = factorDif;} //##ModelId=416F9F9C0256 float getFactorDifusion ( void) { return(factorDifusion);} //##ModelId=416F9F9C0254 void setUmbralDifusion ( float umbralDif ) { umbralDifusion = umbralDif;} //##ModelId=416F9F9C0252 float getUmbralDifusion ( void) { return(umbralDifusion);} }; #endif /* _INC_FILTRARDIFUSION3D_4086837102DE_INCLUDED */ /*******************************************************************/
El fichero fuente (filtradoDifusion3D.cpp):
de
esta
clase
se
incluye
continuacin
/*******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation //#include "stdafx.h" #include "filtradoDifusion3D.h" #include "vtkRenderer.h" #include "vtkRenderWindow.h" #include "vtkRenderWindowInteractor.h" #include "vtkImageReader.h" #include "vtkContourFilter.h" #include "vtkSmoothPolyDataFilter.h"
#include "vtkPolyDataNormals.h" #include "vtkPolyDataMapper.h" #include "vtkActor.h" #include "vtkOutlineFilter.h" #include "vtkCamera.h" #include "vtkProperty.h" #include "vtkMergePoints.h" #include "vtkImageAnisotropicDiffusion3D.h" #define BIORAD_HEADER_LENGTH 76 #define BYTE_TO_WORD(lsb,msb) (((unsigned char) lsb) + (((unsigned char) msb) << 8)) #define ERROR_APERTURA_PIC -1 #define ERROR_NUMERO_COLUMNAS -2 #define ERROR_NUMERO_FILAS -3 #define ERROR_NUMERO_CORTES -4 //##ModelId=4086838B0242 filtradoDifusion3D::filtrarDifusion3D(const char*nombreFich,int primerCorte,int ultimoCorte) { //Creamos el renderer, renderwindow y rederwindowinteracior vtkRenderer *aRenderer = vtkRenderer::New(); vtkRenderWindow *renWin = vtkRenderWindow::New(); renWin->AddRenderer(aRenderer); vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New(); iren->SetRenderWindow(renWin); int nx, ny, nz; unsigned char *head2 = new unsigned char[76]; //Apertura del fichero.pic y comprobacin de que nombreFich contiene el nombre de //un fichero .pic FILE *head1; head1 = fopen(nombreFich,"rb"); if (head1 == NULL) return (ERROR_APERTURA_PIC); //Lectura de la cabecera del fichero PIC BIORAD fread(head2,sizeof(unsigned char),BIORAD_HEADER_LENGTH,head1);
nx = BYTE_TO_WORD(head2[0], head2[1]); ny = BYTE_TO_WORD(head2[2], head2[3]); nz = BYTE_TO_WORD(head2[4], head2[5]); fclose(head1); //Verificaciones if ( nx <= 0 ) return (ERROR_NUMERO_COLUMNAS); if ( ny <= 0 ) return (ERROR_NUMERO_FILAS); if ( nz <= 0 ) return (ERROR_NUMERO_CORTES); nx = nx -1; ny = ny -1; nz = nz -1; //Creamos el ImageReader: vtkImageReader *reader = vtkImageReader::New(); reader->SetFileName(nombreFich); reader->SetFileDimensionality(3); reader->SetDataExtent(0, nx, 0, ny, 0, nz); reader->SetDataVOI(0, nx, 0, ny, primerCorte, ultimoCorte); reader->SetDataOrigin(0, 0, 0); reader->SetDataScalarTypeToUnsignedChar(); reader->SetDataSpacing(1.0, 1.0, 0.2); reader->SetHeaderSize(76);
//Creamos el filtro de difusin anisotrpica y conectamos su entrada con la salida del //reader: vtkImageAnisotropicDiffusion3D *difusor = vtkImageAnisotropicDiffusion3D::New(); difusor->SetInput(reader->GetOutput()); difusor->CornersOn(); difusor->EdgesOn(); difusor->FacesOn(); difusor->GradientMagnitudeThresholdOn(); difusor->SetNumberOfIterations(nIteraciones); difusor->SetDiffusionThreshold(umbralDifusion);
difusor->SetDiffusionFactor(factorDifusion); difusor->Update(); //Aplicamos los filtros, mappers y actores necesarios: vtkContourFilter *skinExtractor = vtkContourFilter::New(); skinExtractor->SetInput((vtkDataSet *) difusor->GetOutput()); skinExtractor->SetValue(0, 254); vtkSmoothPolyDataFilter *smooth = vtkSmoothPolyDataFilter::New(); smooth->SetInput(skinExtractor->GetOutput()); smooth->SetNumberOfIterations(50); smooth->BoundarySmoothingOn(); smooth->SetFeatureAngle(120); smooth->SetEdgeAngle(90); smooth->SetRelaxationFactor(.025); vtkPolyDataNormals *skinNormals = vtkPolyDataNormals::New(); skinNormals->SetInput(smooth->GetOutput()); skinNormals->SetFeatureAngle(60.0); vtkPolyDataMapper *skinMapper = vtkPolyDataMapper::New(); skinMapper->SetInput(skinNormals->GetOutput()); skinMapper->ScalarVisibilityOff(); vtkActor *skin = vtkActor::New(); skin->SetMapper(skinMapper); vtkOutlineFilter *outlineData = vtkOutlineFilter::New(); outlineData->SetInput((vtkDataSet *) reader->GetOutput()); vtkPolyDataMapper *mapOutline = vtkPolyDataMapper::New(); mapOutline->SetInput(outlineData->GetOutput()); vtkActor *outline = vtkActor::New(); outline->SetMapper(mapOutline); outline->GetProperty()->SetColor(0,0,0); //Creamos la cmara, estableciendo sus parmetros: vtkCamera *aCamera = vtkCamera::New(); aCamera->SetViewUp (0, 0, -1); aCamera->SetPosition (0, 1, 0); aCamera->SetFocalPoint (0, 0, 0); aCamera->ComputeViewPlaneNormal();
149
//Aadimos los actores al renderer y establecemos sus parmetros: aRenderer->AddActor(outline); aRenderer->AddActor(skin); aRenderer->SetActiveCamera(aCamera); aRenderer->ResetCamera (); aCamera->Dolly(1.5); aRenderer->SetBackground(1,1,1); renWin->SetSize(512, 512); aRenderer->ResetCameraClippingRange (); //Iniciamos la renderizacin iren->Initialize(); iren->Start(); //Libreamos todos los objetos creados difusor->Delete(); smooth->Delete(); skinExtractor->Delete(); skinNormals->Delete(); skinMapper->Delete(); skin->Delete(); outlineData->Delete(); mapOutline->Delete(); outline->Delete(); aCamera->Delete(); iren->Delete(); renWin->Delete(); aRenderer->Delete(); return 0; } /******************************************************************/
7.5.1.5 Clase vistaFiltradoDifusin2D3D La clase vistaFiltradoDifusin2D3D es la clase encargada de gestionar el programa. A travs de ella se accede a las clases restantes, y se establecen sus parmetros. Es la encargada de interactuar con el usuario, mediante un men de
150
opciones, que permite seleccionar la opcin deseada de entre las que presenta el programa.
Figura 7.28: Clase vistaFiltradoDifusin2D3D
A continuacin se presenta el fichero de cabecera de esta clase (vistaFiltradoDifusin2D3D.h):
/******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation #if defined (_MSC_VER) && (_MSC_VER >= 1000) #pragma once #endif #ifndef _INC_VISTAFILTRADODIFUSION2D3D_40868690034B_INCLUDED #define _INC_VISTAFILTRADODIFUSION2D3D_40868690034B_INCLUDED class visualizacion2D; class visualizacion3D; //##ModelId=416F9F9C02AF class vistaFiltradoDifusion2D3D { public: //##ModelId=416F9F9C02B0 vistaFiltrarDifusion2D3D(); }; #endif /* _INC_VISUALIZAR2D3D_40868690034B_INCLUDED */ /******************************************************************/
El fichero fuente de esta clase (vistaFiltradoDifusin2D3D.cpp), incluye el men de opciones, y el cdigo necesario para que el usuario establezca los parmetros a definir, segn la opcin elegida, para el correcto funcionamiento del programa.
151
/******************************************************************/ // Copyright (C) 1991 - 1999 Rational Software Corporation //#include "stdafx.h" #include <iostream> #include "filtradoDifusion2D.h" #include "filtradoDifusion3D.h" #include "visualizacion2D.h" #include "visualizacion3D.h" #include "vistaFiltradoDifusion2D3D.h"
//##ModelId=408686CD03D8 vistaFiltradoDifusion2D3D::vistaFiltrarDifusion2D3D() { char opcion='0'; char file2[300]; int prim,ult,error=0; int nIter; float umbralDif, factorDif;
//Men de opciones while (opcion!='5') { std::cout<<"Opciones disponibles:"<<std::endl << std::endl; std::cout<<" 1- Visualizacion 2D\n 2- Filtrado de difusion 2D" <<std::endl; std::cout<<" 3- Visualizacion 3D\n 4- Filtrado de difusion 3D\n 5- Salir" << std::endl<<std::endl; std::cout<<"Elige la opcion deseada: "; std::cin>> opcion; std::cout<<" "<<std::endl; switch (opcion){ case '1':{ std::cout<<"Introduce .jpg:"<<std::endl; std::cin>>file2;
el
nombre
del
fichero
visualizacion2D imagen2D; imagen2D.setNombreFich(file2); error imagen2D.visualizar2D(imagen2D.getNombreFich()); if (error==-1)

152
std::cout<<"El archivo indicado no tiene formato .jpg "<<std::endl; }; break; case '2':{ std::cout<<"Introduce el nombre del fichero .jpg:"<<std::endl; std::cin>>file2; std::cout << "Indica los parametros de filtrado:"<<std::endl<<std::endl; std::cout << "Factor de difusion: "; std::cin >> factorDif; std::cout << "Umbral de difusion: "; std::cin >> umbralDif; std::cout << "Numero de iteraciones: "; std::cin >> nIter; filtradoDifusion2D filtro2D; filtro2D.setNombreFich(file2); filtro2D.setFactorDifusion(factorDif); filtro2D.setUmbralDifusion(umbralDif); filtro2D.setIteraciones(nIter); error = filtro2D.filtrarDifusion2D(filtro2D.getNombreFich()); if (error==-1) std::cout<<"El archivo indicado no tiene formato .jpg "<<std::endl; }; break; case '3':{ std::cout<<"\nIntroduce el nombre del fichero .pic: "<<std::endl; std::cin>>file2; std::cout<<"Introduce el numero del primer corte: "; std::cin>>prim; std::cout<<"Introduce el numero del ultimo corte: "; std::cin>>ult; visualizacion3D imagen3D; imagen3D.setNombreFich(file2); imagen3D.setPrimerCorte(prim); imagen3D.setUltimoCorte(ult); error=imagen3D.visualizar3D(imagen3D.getNombreFich(),imagen3D. getPrimerCorte(),imagen3D.getUltimoCorte());
153
switch (error){ case -1: std::cout<<"El archivo indicado no tiene formato .pic"<<std::endl; break; case -2: std::cout<<"Numero de columnas incorreto"<<std:: endl; break; case -3: std::cout<<"Numero de filas incorreto"<< std::endl; break; case -4: std::cout<<"Numero de cortes incorrecto"<<std:: endl; break; } }; break; case '4':{ std::cout<<"\nIntroduce el nombre del fichero .pic: "<<std::endl; std::cin>>file2; std::cout<<"Introduce el numero del primer corte: "; std::cin>>prim; std::cout<<"Introduce el numero del ultimo corte: "; std::cin>>ult; std::cout << "Indica los parametros de filtrado:"<<std::endl<<std::endl; std::cout << "Factor de difusion: "; std::cin >> factorDif; std::cout << "Umbral de difusion: "; std::cin >> umbralDif; std::cout << "Numero de iteraciones: "; std::cin >> nIter; filtradoDifusion3D filtro3D; filtro3D.setNombreFich(file2); filtro3D.setPrimerCorte(prim); filtro3D.setUltimoCorte(ult); filtro3D.setFactorDifusion(factorDif); filtro3D.setUmbralDifusion(umbralDif); filtro3D.setIteraciones(nIter); error = filtro3D.filtrarDifusion3D(filtro3D.getNombreFich(),filtro3D.getPrimerCorte(),fil tro3D.getUltimoCorte());
154
switch (error){ case -1: std::cout<<"El archivo indicado no tiene formato .pic"<<std::endl; break; case -2: std::cout<<"Numero de columnas incorreto"<<std:: endl; break; case -3: std::cout<<"Numero de filas incorreto"<< std::endl; break; case -4: std::cout<<"Numero de cortes incorrecto"<<std:: endl; break; } }; break; case '5': break; default: std::cout << "Opcion no valida." << std::endl <<std::endl; } } } /******************************************************************/
7.5.2 Fichero principal de la aplicacin El fichero principal de la aplicacin es el que contiene a la funcin main( ). Esta funcin se emplea para iniciar el programa, y simplemente se encarga de crear un objeto de la clase vistaFiltradoDifusin2D3D, que gestionar la aplicacin. El archivo fuente del fichero principal (principalVisualizacin2D3D.cpp), se muestra a continuacin: /******************************************************************/ #include <iostream> #include "vtkRenderer.h" #include "vtkRenderWindow.h" #include "vtkJPEGReader.h" #include "vtkImageAnisotropicDiffusion2D.h"
#include "vtkRenderWindowInteractor.h" #include "vtkImageMapper.h" #include "vtkActor2D.h" #include "vtkImageViewer.h" #include "vistaFiltradoDifusion2D3D.h" void main() { vistaFiltradoDifusion2D3D vista1; vista1.vistaFiltrarDifusion2D3D(); } /******************************************************************/
7.5.3 Archivo CMakeLists Como ya hemos visto en captulos anteriores, para poder compilar una aplicacin que emplee las libreras de VTK es necesario utilizar la herramienta CMake. Se incluye a continuacin el archivo de texto CMakeLists necesario para posibilitar la compilacin de la aplicacin difusin2D3D:
/*******************************************************************/ PROJECT (visualizacion2D3D_0.2) INCLUDE (${CMAKE_ROOT}/Modules/FindVTK.cmake) IF (USE_VTK_FILE) INCLUDE(${USE_VTK_FILE}) ENDIF (USE_VTK_FILE) ADD_EXECUTABLE(principalVisualizacion2D3D principalVisualizacion2D3D.cpp) TARGET_LINK_LIBRARIES(principalVisualizacion2D3D vtkRendering vtkIO) /*******************************************************************/
156
Conclusiones
8.1 Principales aportaciones

En este proyecto se ha tratado de desarrollar un estudio sobre distintos algoritmos de procesamiento y visualizacin de imgenes. Como herramienta para este fin, se han empleado las libreras de VTK, llevando a cabo un anlisis bastante completo de las mismas, desde su instalacin hasta su funcionamiento en C++, incluyendo ejemplos significativos. Estudiar, analizar y describir imgenes mdicas a partir del procesamiento digital, constituye en la actualidad, una herramienta de trabajo, cuya precisin facilita al especialista la obtencin de inferencias de valor diagnstico y pronstico de enfermedades, con el lgico beneficio para el paciente. En la actualidad, las aplicaciones de tratamiento y anlisis de imgenes aparecen frecuentemente integradas con aplicaciones de visualizacin tridimensional. Adems de detectar y localizar zonas de inters, los usuarios de las aplicaciones informticas de imgenes mdicas (radilogos, cirujanos, etc.) desean en general mostrar dichas zonas visualizndolas tridimensionalmente, aprovechando de este modo la naturaleza tridimensional de la mayora de las imgenes utilizadas. As, los mdicos demandan de forma creciente aplicaciones que integren tcnicas de tratamiento y anlisis con funcionalidades de visualizacin tridimensional. De todo esto podemos derivar la
Conclusiones
importancia del estudio realizado en este proyecto sobre la visualizacin de imgenes 3D a partir de una pila de imgenes 2D obtenidas con microscopa confocal. La creacin de aplicaciones basadas en el modelado UML es una herramienta muy importante en la ingeniera del software. Al ser un modelo basado en componentes, conduce a la reutilizacin del software, brindando importantes beneficios al grupo desarrollador. Por ello, la aplicacin difusin 2D3D puede tener cierta importancia como ejemplo orientativo de utilizacin de este modelo.
8.2 Futuras mejoras

Son muchas las mejoras que se pueden hacer a todo lo desarrollado a lo largo de este proyecto, algunas de ellas son: Profundizar en el estudio de las herramientas de visualizacin de imgenes distintas de las VTK, para poder llevar a cabo una comparativa con las mismas, y as determinar cul es la ms apropiada en cada momento, segn nuestros objetivos. Aunque el anlisis de las libreras VTK es bastante completo, el estudio de su funcionamiento slo se ha tratado bajo el lenguaje C++. Podra llevarse a cabo un anlisis y comparativa de su funcionamiento con otros de los lenguajes de programacin que soporta, como Java, Tcl/Tk, o Python. Realizar un estudio de tcnicas de reconstruccin 3D distintas de las expuestas, como Marching Cubes, para poder decidir emplear la ms apropiada en cada caso. Ahondar en el estudio de las distintas tcnicas de filtrado de difusin, isotrpica y anisotrpica, y en la combinacin de las mismas. La aplicacin difusin2D3D es susceptible de muchas mejoras, entre otras, la culminacin de algunos de los objetivos que aparecan en su documento de visin y alcance, y que no han sido llevados a cabo en este proyecto. Entre ellos, cabe destacar la creacin de un GUI (Grafical User Interface), mediante las libreras MFC, que permita al usuario decidir entre las distintas opciones de uso del programa, as como introducir los parmetros necesarios para su funcionamiento de manera ms sencilla. La opcin de procesamiento distribudo para mejorar el tiempo de ejecucin al llevar a cabo el filtrado de difusin tampoco ha sido includa en esta aplicacin, aunque su implementacin ha sido desarrollada con xito en otros proyectos. Aunque no aparezca en su documento de visin y alcance, la aplicacin difusin2D3D podra completarse con la inclusin de nuevos tipos de algoritmos de filtrado, distintos de la difusin, que permitan emplear el ms
158
Conclusiones
adecuado en cada caso. Tambin se podra tratar de llevar a cabo la visualizacin y tratamiento de imgenes PIC en color, y no slo en escala de grises. Empleando VTK, y siguiendo el mtodo de modelado UML, podran crearse multitud de aplicaciones del estilo de la implementada en este proyecto, que permitan explotar las capacidades de VTK en lo que respecta al desarrollo de algoritmos de procesamiento de imgenes.
Estas son slo algunas de las posibles mejoras a este proyecto, aunque podran incluirse muchas ms, ya que es lgico que cualquier aplicacin software, sea susceptible de nuevas mejoras que mejoren el funcionamiento global de la aplicacin, o de nuevas aplicaciones que den ms versatilidad a los programas diseados.
159
Conclusiones
160
Bibliografa
PROCESAMIENTO DE IMGENES
Thomas Bauer,Processing and 3D visualization of biological volumes of confocal microscopy, Grupo de Visin Artificial (GVA), Escuela Universitaria de Ingeniera Tcnica Industrial de Madrid, www.elai.upm.es Marta Garca Nuevo, Procesamiento y Visualizacin Tridimensional de Imgenes Biomdicas del Microscopio Confocal, Grupo de Visin Artificial (GVA), Escuela Universitaria de Ingeniera Tcnica Industrial de Madrid, www.elai.upm.es Mihai Spulber, Implementation of biomedical tools, Grupo de Visin Artificial (GVA), Escuela Universitaria de Ingeniera Tcnica Industrial de Madrid, www.elai.upm.es David Lpez Peinado, Implementacin multiplataforma de algoritmos de procesamiento de imgenes biomdicas 2D en Matlab y C++, Grupo de Visin Artificial (GVA), Escuela Universitaria de Ingeniera Tcnica Industrial de Madrid, www.elai.upm.es
161
Bibliografa
Carlos Platero, Gabriel Asensio, Jorge Moreno, Combinacin de la difusin isotrpica y anisotropica en el procesamiento de imgenes, Escuela Universitaria de Ingeniera Tcnica Industrial de Madrid. http://www.exaflop.org/docs/marchcubes/ind.html Marching Cubes http://www.ldc.usb.ve/~vtheok/cursos/ci5322/marching/marching.html Marching Cubes http://www.kitware.com
VTK
Kitware, Inc., The Visualization Toolkit User's Guide,publicado por Kitware, Inc. Gua del usuario para la versin 4.2 de VTK Kitware, Inc., The Visualization Toolkit, An Object-Oriented Approach To 3D Graphics, 3rd edition, publicado por Kitware, Inc. Algoritmos de visualizacin y estructuras de datos. http://www.vtk.org http://public.kitware.com/mailman/listinfo/vtkusers Mailing-List http://public.kitware.com/cgi-bin/vtkfaq FAQ de VTK http://www.cmake.org/ Pgina oficial de CMake
OTRAS HERRAMIENTAS DE VISUALIZACIN

http://www.itk.org/ Pgina oficial de ITK http://www.paraview.org/HTML/Index.html Pgina oficial de Paraview http://www.mathworks.com/products/matlab/ Pgina oficial de Matlab
162
Bibliografa
MODELADO UML Y RATIONAL ROSE

Mihai Spulber, Implementation of biomedical tools, Grupo de Visin Artificial (GVA), Escuela Universitaria de Ingeniera Tcnica Industrial de Madrid, www.elai.upm.es Carlos Platero Dueas, Prcticas de Informtica Industrial, Escuela Universitaria de Ingeniera Tcnica Industrial de Madrid. http://www.uml.org/ http://www-306.ibm.com/software/rational/ http://www.vico.org/TallerRationalRose.pdf http://doc.mor.itesm.mx:8181/labvir/archivos/estandares/Modelos_proceso.pdf http://dark.disca.upv.es/enheror/pdf/ActaUML.pdf
C++
http://www.e-manuales.com/dir.asp?cat=/programacion/cc Manuales de C++. http://msdn.microsoft.com/library/ http://www.lafacu.com/apuntes/informatica/Programacion_en_C++/
163
Bibliografa
164

PFC I Berzal

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

PFC I Berzal

Cargado por

Copyright:

Formatos disponibles

Desarrollo de algoritmos de procesamiento de imgenes con VTK

Autor: Ignacio Berzal Moreno Tutor: Carlos Platero Dueas

1.1 Objetivos ...............................................................................2 1.2 Sumario del proyecto ...........................................................3

2.1 Herramientas de visualizacin de imgenes ......................5

Funcionamiento de VTK ........15

3.1 Instalacin de VTK...............................................................16

3.2 Funcionamiento en C++ de VTK.........................................17

4.3 Suavizado del mallado ........................................................41

Aplicaciones sobre una pila

de imgenes del confocal ............45

isotrpica y anisotrpica en el procesamiento de imgenes ........69

Aplicacin del filtrado de

difusin con imgenes JPG y PIC .........................................................83

2D ...............................................................................100 7.3.2.2 Caso de uso visualizar 3D ......................................101

3D ...............................................................................104 7.3.2.3 Caso de uso filtrar difusin 2D ...............................104

difusin 2D...................................................................107 7.3.2.4 Caso de uso filtrar difusin 3D ...............................108

7.4 Creacin de la aplicacin mediante Rational Rose .......112

7.5 Implementacin del cdigo ..............................................128

8.1 Principales aportaciones ..................................................157 8.2 Futuras mejoras ................................................................158

Sumario del proyecto

2.1 Herramientas de visualizacin de imgenes

Figura 2.1: Logo de MATLAB

Figura 2.2: Interfaz de MATLAB

Figura 2.4: Logo de VTK

Visualizacin con VTK

Figura 2.5: Figura procesada con VTK

Desarrollar una arquitectura extensible basada en estndares abiertos.

Figura 2.6: Logo de Paraview

Figura 2.7: Interfaz de Paraview

Figura 2.8: Logo de ITK

Figura 2.9: Ejemplo de imagen binarizada con ITK

Figura 2.10: Logo de OpenMoxis

Figura 2.11: Logo de MPI

Figura 2.12: Logo MPICH

Ignacio Berzal Moreno

3.1 Instalacin de VTK

Figura 3.1 : Instalacin binaria

Ignacio Berzal Moreno

3.2 Funcionamiento en C++ de VTK

Ignacio Berzal Moreno

Figura 3.2: GUI de CMake

Ignacio Berzal Moreno

Ignacio Berzal Moreno

Ignacio Berzal Moreno

Figura 3.3: Datasets empleados por VTK

Ignacio Berzal Moreno

Figura 3.4: Pipeline de visualizacin

Existen varios tipos importantes de process objects:

Figura 3.5: Process objects

Ignacio Berzal Moreno

Figura 3.5: Ejecucin del pipeline

Ignacio Berzal Moreno

Ignacio Berzal Moreno

Ignacio Berzal Moreno

Ignacio Berzal Moreno

Figura 3.6: Renderizacin de un cilindro

Ignacio Berzal Moreno

Ignacio Berzal Moreno

Ignacio Berzal Moreno

Figura 3.7: Renderizacin de un cono

Ignacio Berzal Moreno

Ignacio Berzal Moreno

Ignacio Berzal Moreno

Ignacio Berzal Moreno