Procesamiento

UNIVERSIDAD POLITCNICA DE MADRID
DEPARTAMENTO DE ELECTRNICA, AUTOMTICA E INFORMTICA INDUSTRIAL
Grupo de Visin Artificial
Procesamiento y Visualizacin Tridimensional de Imgenes Biomdicas del Microscopio Confocal

Autor: Tutor: Marta Garca Nuevo Carlos Platero Dueas
Nadie sabe de lo que es capaz hasta que lo intenta. Sirio, Publio
La gota horada la roca, no por su fuerza sino por su constancia. Ovidio
Tras estos aos de estudio concluye una de las etapas de mi vida, a la que este proyecto es el encargado de poner fin. Ha sido mucha la gente que me ha apoyado en estos aos y a todos ellos les quiero dedicar este trabajo. A mis padres y hermano que siempre estn ah para darme un empujoncito cuando ms lo necesito. A mis compaeros de la escuela porque me daban nimo cuando llegaban esos momentos en los que pareca que nada iba a salir bien. Mis compaeros del proyecto David, Ricardo, Jose, Fernando, Abdel, Jeroen, Woter que me han ayudado en todo lo que han podido y sobre todo a Thomas con quien tantas horas he pasado frente a la pantalla de Galileo. Gracias a todos mis amigos por esos momentos de distraccin tan tiles para desconectar de vez en cuando. No quiero olvidarme de los profesores de los que tanto he aprendido y sobre todo a Carlos Platero por invitarme a culminar mi carrera de forma brillante con ste proyecto.
Muchas gracias a todos.
Marta
Resumen
En este proyecto vamos a trabajar con imgenes biomdicas, intentando apoyar a la medicina en el desarrollo de nuevas tcnicas basadas en la Visin Artificial. El proyecto trata de hacer la reconstruccin de imgenes tridimensionales, partiendo de series de imgenes bidimensionales obtenidas con el microscopio confocal. Estas imgenes son difciles de tratar porque ocupan mucho espacio, alrededor de 20 MB. Trataremos de encontrar un modo sencillo y eficaz de visualizar esta imagen tridimensional, e incluso mejorarla utilizando distintas tcnicas de procesamiento digital de imgenes. Para lograr estos objetivos usaremos Matlab con algunas de sus Toolboxes, como Image Processing Toolbox y Morphology Toolbox, tambin usaremos The Visualisation Toolkit (VTK). Como esta visualizacin y procesamiento requiere mucha capacidad computacional, nos sumergiremos en el mundo del clustering, para intentar distribuir el trabajo de los programas que implementemos en varias mquinas y as reducir tiempo requerido para obtener los resultados. El proyecto se realiza dentro del Grupo de Visin Artificial de la Escuela Universitaria de Ingeniera Tcnica Industrial (UPM). Se finaliz en el ao 2003.
Abstract
The aim of this project is work with biomedical images in order to create new techniques based on Artificial Vision that are very important for the medicine. The project tries to reconstruct a 3D representation from a series of 2D images, made with a confocal microscope. The typical size of the data comingfrom the confocal microscope is about 20 MB. We want to find an easy way to displaythe 3D image and to have the possibility to view the volume from different angles.We want to enhance the quality of the images by the means of debluring,enhancement of the signal-to-noise ratio and deconvolution. To reach these goals we use the Matlab software with some additional Toolboxes (e.g. Image ProcessingToolbox, Morphology Toolbox) and the Visualisation Toolkit (VTK). This processing and visualisation needs a very big computational capacity, we will try to develop a computer cluster to calculate processor intensitive tasks.
ndice
1
1.1 1.2
INTRODUCCIN ....................................................................... 1
Objetivos....................................................................................................... 2 Sumario del proyecto .................................................................................. 3
2
2.1
ESTADO DE LA TCNICA ....................................................... 5
Introduccin ................................................................................................. 5
2.2 Principios de la microscopa confocal [SART] [TWIL] [DADA] .......................... 6 2.2.1 Funcionamiento del microscopio confocal [SOTO] ...................................... 6 2.2.2 Limitaciones del microscopio ptico......................................................... 8 2.2.3 Ventajas del microscopio confocal [ABEC] [LOCI] [ERIC] ................................. 8 2.2.4 Otros mtodos para mejorar las imgenes [DADA] .................................... 10 2.2.5 Aplicaciones del microscopio confocal [JDOB] [JMCU] ................................ 10 2.2.6 Imgenes 3D con el microscopio confocal [ABEC] .................................... 12 2.2.7 Limitaciones de la microscopia confocal ................................................ 13
2.3 Eliminacin del ruido ................................................................................ 13 2.3.1 La imagen digital [AMAR] .......................................................................... 13 2.3.2 Deconvolucin [CNBT] ............................................................................... 14 2.3.3 Blind Deconvolucin [JCHI] ...................................................................... 14 2.3.4 Debluring [TMAT]....................................................................................... 15 2.3.5 Denoise .................................................................................................... 16 2.3.6 Renderizacin .......................................................................................... 17 2.3.7 Mtodos de renderizacin........................................................................ 17 2.3.8 Renderizacin en Matlab ......................................................................... 18 2.3.9 Razones para cambiar la renderizacin ................................................... 19 2.4 Aproximacin poligonal [CHEN] [CHXU] ....................................................... 19 2.4.1 Mtodos para realizar la aproximacin poligonal ................................... 21 2.4.2 Esquema de continuidad y proceso de poligonalizacin. ........................ 22 2.4.3 Comentarios............................................................................................. 23 2.5 Procesamiento distribuido [ENZO] [OPIN] ..................................................... 24 2.5.1 Ventajas del procesamiento distribuido................................................... 24 2.5.2 Desventajas del procesamiento distribuido ............................................. 25 2.5.3 Transparencia........................................................................................... 27 2.5.4 Tendencia a lo distribuido ....................................................................... 28 2.5.5 Migracin de procesos............................................................................. 29 2.5.6 Comunicacin entre procesos.................................................................. 30 2.5.7 Entrada salida ....................................................................................... 30 2.5.8 Clusters [OPIN] [KHWA] [SGAL] ....................................................................... 31 2.5.8.1 Caractersticas de los cluster............................................................. 32 2.5.9 Clustering con OpenMosix...................................................................... 34 2.5.9.1 Caractersticas de OpenMosix .......................................................... 36 2.5.10 Clustering con MPI (ParaView) [ACAL] .................................................. 41
3
3.1 3.2 3.3 3.4
3.5
HERRAMIENTAS DE VISUALIZACIN ................................. 45
Matlab [MWOR] [DMUU] .................................................................................. 45 VTK [KITW] .................................................................................................. 47 SDC [SDCM]................................................................................................... 49 OPENMOXIS [NO3D] .................................................................................. 50 PARAVIEW [PARA] ......................................................................................... 51 MPI [CARA] ................................................................................................... 52
3.6
PROCESAMIENTO ................................................................. 55
4.1 Ficheros grficos [FPIC] ............................................................................... 55 4.1.1 Formato grfico *.pic .............................................................................. 56 4.1.2 Regiones de inters (ROI) ....................................................................... 57 4.1.2.1 Seleccin de la ROI ............................................................................ 57 4.1.2.2 Filtrado de la ROI ............................................................................. 58 4.2 Descripcin de los comando usados en los cdigos................................. 58 4.2.1 Apertura del .pic con Matlab ................................................................... 58 4.2.2 Procesamiento de la imagen con Matlab ................................................. 59 4.2.3 Procesamiento de la imagen usando SDC ............................................... 61 4.2.4 Procesamiento de la imagen usando VTK............................................... 63 4.2.5 Procesamiento usando VTK y Matlab..................................................... 65 4.2.6 Observaciones.......................................................................................... 65 4.3 Renderizacin ............................................................................................ 65 4.3.1 Mtodos de renderizacin........................................................................ 66 4.3.2 Renderizacin en Matlab ......................................................................... 66 4.3.3 Renderizacin con VTK .......................................................................... 67 4.3.4 Razones para cambiar la renderizacin ................................................... 67 4.3.5 Renderizacin de volmenes ................................................................... 68 4.3.6 Renderizacin de superficies ................................................................... 68 4.3.7 PICvisu toolbox ....................................................................................... 69 4.3.7.1 openpic.m.......................................................................................... 69 4.3.7.2 vtk3D.m ............................................................................................ 73 4.3.8 PICsuper toolbox ..................................................................................... 80 4.3.8.1 Picsuper / picsuperbw ....................................................................... 80
5
5.1 5.2 5.3
APROXIMACIN POLIGONAL .............................................. 91
Niveles de detalle [MKRU] [CHXU] .................................................................. 91 Simplificacin poligonal ............................................................................ 94 Algoritmos .................................................................................................. 96
5.3.1 5.3.2 5.3.3 5.3.4 5.3.5 5.4
Anlisis de Mallas Arbitrarias de Multiresolucin.................................. 96 Mallas Progresivas................................................................................... 97 Aproximacin de Rango Completo de Poliedros Triangulados .............. 98 Simplificacin por Sobres ....................................................................... 99 Simplificacin de Superficie Dentro de un Volumen de Tolerancia..... 101 Snakes [CHXU]............................................................................................. 103
5.5 Implementacin ....................................................................................... 105 5.5.1 Seleccin de puntos del contorno .......................................................... 106 5.5.2 Unin de los puntos del contorno .......................................................... 107 5.5.3 Aproximacin poligonal en 3D ............................................................. 110 5.6 Conclusiones............................................................................................. 117
6
6.3
PROCESAMIENTO DISTRIBUIDO[ENZO] ............................... 119
6.1 Linux [PHPB] [GLUS] ....................................................................................... 120 6.1.1 Qu es LINUX?.................................................................................... 120 6.1.2 Trabajando con Linux............................................................................ 121 6.1.3 El Shell: comandos bsicos de Linux .................................................... 123 6.1.4 Ejecucin de Programas ........................................................................ 128 6.2 OpenMoxis[MCAT] ..................................................................................... 133 6.2.1 Breves nociones de OpenMosix ............................................................ 133 6.2.1.1 Comandos ms utilizados ............................................................... 134 6.2.2 Cmo construir el cluster....................................................................... 136 6.2.2.1 Ejecutamos un ejemplo................................................................... 137 MPI ........................................................................................................... 141
6.4 ParaView [EHEL] [LBER] .............................................................................. 142 6.4.1 Argumentos de la lnea de comandos .................................................... 143 6.4.2 Ejecucin de ParaView sobre MPI........................................................ 144 6.5 MPICH[DASH] ............................................................................................ 145 6.5.1 Instalacin de MPICH ........................................................................... 145 6.5.2 Herramientas.......................................................................................... 146 6.5.2.1 mpirun............................................................................................. 146 6.5.2.2 MPIRegister tool............................................................................. 147 6.5.2.3 Configuration tool........................................................................... 147 6.5.2.4 Update tool...................................................................................... 149 6.5.3 Ejecutamos un ejemplo.......................................................................... 149
6.6
Conclusiones............................................................................................. 152
7
7.1 7.2 7.3
BIBLIOGRAFA ..................................................................... 153
Microscopio confocal............................................................................... 153 Eliminacin del Ruido ............................................................................. 154 Aproximacin Poligonal.......................................................................... 155
7.4 Procesamiento distribuido ...................................................................... 156 7.4.1 MPI ........................................................................................................ 156 7.4.2 Paraview ................................................................................................ 156 7.4.3 OpenMosix ............................................................................................ 157 7.4.4 Mpich..................................................................................................... 157
8
8.1 8.2 8.3 8.4 8.5
NDICE DE FIGURAS............................................................ 159
Estado de la Tcnica................................................................................ 159 Herramientas de Visualizacin .............................................................. 160 Procesamiento .......................................................................................... 161 Aproximacin Poligonal.......................................................................... 162 Aproximacin Poligonal.......................................................................... 163
Marta Garca Nuevo
Introduccin
Introduccin
El anlisis digital de datos, ms especficamente, imgenes digitales de percepcin remota orbital, posibilit, en los ltimos veinticinco aos, un gran desarrollo de las tcnicas orientadas al anlisis de datos multidimensionales, adquiridos por diversos tipos de sensores. Estas tcnicas han recibido el nombre de procesamiento digital de imgenes. Por Procesamiento Digital de Imgenes se entiende la manipulacin de una imagen a travs de un computador, de modo que la entrada y la salida del proceso sean imgenes. Para comparar, en la disciplina de reconocimiento de patrones, la entrada del proceso es una imagen y la salida consiste en una clasificacin o una descripcin de la misma. Por otro lado, la elaboracin de grficos por computador envuelve la creacin de imgenes a partir de descripciones de las mismas. El objetivo de utilizar el procesamiento digital de imgenes, es mejorar el aspecto visual de ciertos elementos estructurales para el analista y proveer otros subsidios para su interpretacin, inclusive generando productos que puedan ser posteriormente sometidos a otros procesamientos.
GVA-ELAI-UPMPFC0077-2003
Introduccin
Marta Garca Nuevo
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 est permitiendo una gama de aplicaciones cada vez mayor. 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. Son muchas las tcnicas de procesamiento digital empleadas en el campo de la medicina. Estas van desde el mejoramiento de contraste, la deteccin de contornos, hasta los ms complejos sistemas de reconocimiento de patrones y reconstrucciones tridimensionales. Con todo esto, vemos como la Informtica ha impulsado con fuerza el desarrollo de la Medicina en stas ltimas dcadas, para beneficio de todos.
1.1 Objetivos
El objetivo fundamental de este proyecto es, como su ttulo indica: Procesamiento y visualizacin 3D de cuerpos biolgicos mediante microscopio confocal. Para lograr este objetivo general dividiremos el trabajo en los procesos algo ms especficos, estos son: Procesamiento de imgenes del microscopio confocal. Visualizacin 2D. Visualizacin 3D. Renderizacin y eliminacin del ruido. Implementacin de algoritmos para el estudio de imgenes biomdicas. Aproximacin Poligonal. Procesamiento distribuido. Todos estos pasos estn ntimamente ligados, unos conducen a otros, para al final obtener con xito nuestro objetivo, una correcta visualizacin de las imgenes del microscopio confocal, adecuadas para facilitar en trabajo que queramos realizar con ellas.
Marta Garca Nuevo
Introduccin
1.2 Sumario del proyecto

El proyecto se estructura en seis captulos y dos anexos. En los primeros captulos se describe algunos de los avances obtenidos en los campos sobre los que va a tratar el proyecto y se explica en que van a consistir y el fin del trabajo que se desarrolla en sucesivos captulos. En el tercer captulo el proyecto enumera las herramientas que vamos a utilizar para realizar el trabajo. El cuarto captulo habla sobre el microscopio confocal, las imgenes que se obtienen con l y el procesamiento que se realiza sobre ellas. Con el microscopio confocal obtenemos imgenes en dos dimensiones. Estas imgenes son los cortes virtuales de una muestra, realizados cada 0.5 micras aproximadamente. Estas imgenes llegan a nosotros en un formato grfico *.pic, que tenemos que leer y visualizar. Para visualizar este formato, usaremos fundamentalmente la programacin en Matlab y las VTK. Estos programas y bibliotecas nos servirn tambin para realizar la composicin de estas imgenes bidimensionales, para su representacin tridimensional. Una vez capaces de leer y representar las imgenes, tendremos que mejorarlas y adaptarlas para facilitar la operacin que en el futuro queramos realizar con stas. Para ello empleamos distintas tcnicas de filtrado, deconvoluciones y finalmente su renderizacin. Todo esto lo haremos implementando los algoritmos adecuados en los lenguajes convenientes, en nuestro caso Matlab y TCL. Para describir todo lo relativo a la aproximacin poligonal que se realiza sobre nuestras imgenes tenemos el quinto captulo. Para simplificar las imgenes con las que estamos trabajando y no manejar un volumen de datos tan grande, trataremos de hacer una aproximacin poligonal a nuestra imagen, utilizando los mismos programas que hasta ahora. Hacer la aproximacin poligonal de una imagen consiste en trazar un contorno ms o menos preciso segn sea necesario y transformar una compleja imagen en un conjunto de lneas que se ajustan a su superficie ocupando mucho menos espacio. En el sexto captulo tratamos todo lo referente al procesamiento distribuido, analizamos la construccin de un cluster y su manejo.
Introduccin
Marta Garca Nuevo
Al procesar imgenes completas nos encontramos con la necesidad de una capacidad computacional muy elevada, y un tiempo de procesamiento tambin demasiado largo. Para tratar de reducir este tiempo y poder usar computadores menos potentes realizaremos el procesamiento distribuido en varias mquinas. Este procesamiento distribuido lo haremos de dos formas diferentes, bajo Linux usando OpenMosix, y bajo Windows usando Mpich. El apndice A, nos muestra la bibliografa utilizada y el anexo B es el ndice de las imgenes incluidas en el proyecto.
Marta Garca Nuevo
Estado de la Tcnica
Estado de la tcnica
2.1 Introduccin
Generalmente, las imgenes biomdicas son interpretadas por expertos humanos, pero cuando las condiciones de las imgenes no son buenas, o se cuenta con un gran nmero de ellas, el trabajo de analizarlas se vuelve sumamente tedioso y montono, siendo propenso a errores, o bien, que por cansancio, se evita un anlisis minucioso. Es aqu donde el desarrollo de algoritmos de anlisis de imgenes permitir automatizar muchas de las tareas, y se convertir en una gran herramienta del analista humano. Dejndole las imgenes preanalizadas o cuantificadas, para que slo se concentre en el trabajo ms creativo y en la interpretacin o diagnstico final. Este captulo pretende ser una breve presentacin, de los proyectos y lneas de investigacin, que se han elaborado o se estn desarrollando en la actualidad en el campo del procesamiento y anlisis digital de imgenes biomdicas. Cmo este proyecto se centra en el proceso y anlisis 2D y 3D de imgenes biomdicas, en este captulo se har hincapi en los proyectos que puedan ser de inters para la comprensin de este o puedan resultar complementarios.
Estado de la Tcnica
Marta Garca Nuevo
Tambin se darn nociones de los avances en la aproximacin poligonal hechos hasta la fecha. Analizando los objetivos buscados y el modo de obtener los mejores resultados cuanto a velocidad de procesamiento y sencillez de manejo.
2.2 Principios de la microscopa confocal [SART] [TWIL] [DADA]

La Microscopa Confocal permite el estudio de muestras con marcaje fluorescente, haciendo secciones pticas de las mismas. Se excita la muestra punto a punto por medio de un lser. La longitud de onda de emisin de esa muestra es mayor a la de excitacin, y es esta ltima la que al pasar por un pequeo diafragma (pinhole) permite la deteccin de un solo plano focal. Esta tcnica microscpica se basa iluminar una muestra y eliminar la luz reflejada o fluorescente de los planos fuera de foco, de este modo se obtienen imgenes de mayor nitidez y contraste permitiendo adems el estudio tridimensional de la muestra. Se puede utilizar con especimenes con autofluorescencia o susceptibles de ser teidos por una sustancia fluorescentes. Tambin se puede utilizar en muestras metlicas que reflejen la luz. Tiene aplicaciones en: biologa celular y molecular (estudios de estructuras celulares y citoesqueleto), estudios de microbiologa, gentica, biologa vegetal, anatoma patolgica, neurologa, ciencias de los alimentos, ciencias de materiales (fracturas metlicas), geologa (estudios de microfisuras y porosidad en rocas) , etc. Figura 2.1: Imagen del confocal 2.2.1 Funcionamiento del microscopio confocal [SOTO] Este nuevo tipo de microscopio se basa en eliminar el velo que, en una imagen de microscopa ptica normal, producen las regiones que se encuentran fuera del plano de foco. Para esto, se ha optado por pasar la luz que incide sobre la muestra por un pequeo agujero o ranura y enfocarla en el plano de la imagen de un objetivo de gran apertura numrica . De esta manera, la luz que es reflejada por el punto que se encuentra en el plano focal del objetivo, regresa al mismo y es reenfocada y transmitida a su vez por un pequeo agujero o ranura sin ninguna prdida. En cambio, la luz dispersada o emitida por los puntos que se encuentran fuera del plano de la imagen es atenuada o bloqueada completamente. De esta manera, se obtiene una imagen de alto contraste y definicin de un punto en el plano focal, sin que haya una contribucin significativa de las regiones que se encuentran fuera de foco. Debido a que las aperturas tanto de la iluminacin como del retorno de la imagen tienen un foco comn, se ha denominado este tipo de microscopios como "microscopio confocal". Puede resumirse su funcin diciendo que la microscopa confocal se basa en mejorar la relacin entre la seal y el ruido de la imagen. En la figura se muestra un esquema de un tipo particular de microscopio confocal: en el cual, la fuente de luz que se utiliza es un rayo lser. El haz de luz se hace pasar por
Marta Garca Nuevo
Estado de la Tcnica
una ranura (P1) e incidir en un espejo dicroico (que refleja totalmente la luz que incide con un ngulo de cerca de 45 grados), para posteriormente enfocarlo sobre la muestra usando el propio objetivo del microscopio. La luz emitida por la muestra es colectada por el mismo objetivo y, pasando a travs del espejo dicroico es enfocada en una ranura detectora (P2). La luz que penetra a menor o mayor profundidad en la muestra (planos fuera de foco), incide por delante o por detrs de la ranura detectora (haces de luz representados en lneas punteadas en la figura. Debido a que la cantidad de luz que incide sobre la muestra es sumamente pequea, es necesario usar fuentes de iluminacin muy poderosas como es el rayo lser.
Figura 2.2: Esquema del microscopio confocal
El procedimiento descrito, nos da la imagen de un pequeo punto de la muestra, para obtener una imagen completa es necesario usar complejos procedimientos que permitan mover el punto de iluminacin en toda la muestra, e integrar esta imagen formada de puntos individuales en una imagen nica. Para esto, se usan sistemas que permiten desplazar la muestra o mover el punto de iluminacin, barriendo toda el rea que se desea observar. Por esto ltimo, se denomina a los microscopios como "microscopio confocal de barrido". Como resultar obvio, para construir una imagen es necesario recorrer toda la muestra de manera uniforme, adems de que el rayo de iluminacin y la va de retorno, debern estar perfectamente alineadas. Esto implica que la mayora de los instrumentos que hasta ahora se han desarrollado, se basen en complejos sistemas electromecnicos que resultan en un alto costo, ya que tienen que generarse pequeos desplazamientos perfectamente uniformes, e integrarse la imagen en un computador.
Estado de la Tcnica
Marta Garca Nuevo
Para eliminar el problema asociado con el diseo de sistemas que permitan barrer la imagen, se han ofrecido diversas alternativas, algunas de las cuales se encuentran ya en microscopios confocales comerciales. Uno de stos es el microscopio confocal en que el barrido lo hace el haz de luz. Para ello se utilizan espejos dicroicos que vibran rpidamente recorriendo todo el espcimen. Otra solucin al problema lo constituye el "microscopio confocal de barrido en cascada". En el cual, un pequeo anillo que se encuentra por detrs del objetivo tiene mltiples hoyos (de 20 a 60 micras de dimetro) en forma de espiral, al rotar este anillo, se genera una imagen completa de toda la preparacin, tomando simultneamente muestras de una gran cantidad de puntos no adyacentes. Este tipo de microscopio tiene la ventaja de que se obtienen imgenes en tiempo real, permitiendo la observacin directa en el microscopio.
Figura 2.3: Microscopio confocal real 2.2.2 Limitaciones del microscopio ptico Cuando usamos un microscopio ptico convencional para observar objetos como clulas completas, la imagen que visualizamos es poco definida y de todas las estructuras de la clula a la vez. Si enfocamos sobre una zona determinada tambin veremos las reas situadas fuera de foco dando como resultado una imagen borrosa. Adems no podemos hacernos una idea de la distribucin tridimensional de las diferentes organelas. Cuando queremos observar imgenes definidas, debemos recurrir a realizar cortes finos de la muestra, pero esto es imposible cuando lo que estamos estudiando son clulas vivas. 2.2.3 Ventajas del microscopio confocal [ABEC] [LOCI] [ERIC] El microscopio confocal permite que solo observemos el plano que est situado en el punto de foco del sistema ptico eliminando, de forma ptica a travs de un diafragma o "pinhole", la luz proveniente de los planos que estn fuera de foco.
Marta Garca Nuevo
Estado de la Tcnica
Cualquiera que sea el procedimiento que se utilice para barrer la muestra, las imgenes del microscopio confocal son notablemente superiores a las que se obtienen con el microscopio ptico convencional, ya que las imgenes generadas contienen detalles volumtricos y de textura imposibles de alcanzar con este ltimo. Una ventaja adicional se obtiene en los casos en que se desea explorar especimenes con fluorescencia. En estos casos, el efecto deletreo que sobre la imagen tienen las reas fuera de foco es especialmente notable; adems, la iluminacin de la muestra hace que se pierda rpidamente la fluorescencia. Por estas razones, el microscopio confocal es especialmente ventajoso para observar especimenes fluorescentes, ya que adems de eliminar el efecto de las regiones fuera de foco, solamente se ilumina una pequesima regin de la muestra en cada momento, eliminndose con ello el efecto de "blanqueado" que, sobre la fluorescencia, induce la iluminacin continua. La microscopa confocal permite tambin estudiar los especimenes usando luz transmitida o reflejada, ello implica que se puedan estudiar muestras que, por su grosor o por sus caractersticas, no son transparentes. Esto ha permitido que se desarrollen nuevas tcnicas de preparacin de los especimenes a observar, las cuales no implican el corte en rebanadas delgadas como se hacia anteriormente, ampliando as significativamente las posibilidades de estudiar las relaciones estructura-funcin, ya sea a nivel uni o multicelular.
Figura 2.4: Ejemplo del uso de luces
La importancia de la microscopa confocal radica entonces en que constituye una nueva y poderosa herramienta para examinar las estructuras celulares y sus funciones. Podemos resumir sus ventajas diciendo que: 1) Pueden observarse tejidos intactos as como secciones gruesas sin necesidad de hacer cortes histolgicos. 2) Se obtiene un aumento notable en la resolucin, especialmente en muestras con fluorescencia. 3) Reduce el blanqueado de la fluorescencia. 4) Permite hacer reconstrucciones tridimensionales ms precisas de mejor calidad y en menor tiempo que por otros mtodos.
Estado de la Tcnica
Marta Garca Nuevo
Por todo lo anterior, es claro que en el corto plazo, el microscopio confocal pasar a formar parte del instrumental normal de trabajo, tanto en laboratorios de anlisis clnicopatolgico, como en los laboratorios de investigacin bsica, ya que se ha convertido en un auxiliar indispensable en los estudios de tipo funcional, en los cuales se pretende determinar los procesos que se llevan a cabo en tejidos vivos. Como resultado del desarrollo de la microscopa confocal, y de los mtodos digitales de anlisis de imgenes, es posible actualmente abordar cuestiones relativas a las relaciones estructura-funcin en los seres vivos, que anteriormente eran incontestables. 2.2.4 Otros mtodos para mejorar las imgenes [DADA] Se han desarrollado, adems de la microscopa confocal, otros mtodos que permiten mejorar significativamente la calidad de las imgenes que se obtienen con el microscopio ptico. Estos mtodos se basan en el procesamiento digital de imgenes, por medio de procedimientos matemticos que permiten calcular y eliminar el velo debido a las regiones que se encuentran fuera de foco. Otros mtodos, para mejorar la calidad de imgenes en la microscopa, se basan en modificaciones en los ngulos de incidencia de la luz y, en el uso de varios haces de luz para iluminar las muestras. Actualmente es posible separar las reas enfocadas de las que estn fuera de foco mediante complicados algoritmos matemticos integrados en programas informticos que son aplicados al conjunto de imgenes por un gran ordenador. A este tipos de programas se les denomina de "deconvolucin", anglicismo que quiere decir algo as como desenrollamiento o desenmarallamiento. Aunque se pueden obtener resultados magnficos, los requerimientos hardware y software y el aprendizaje del manejo de los mismos hacen que solo se usen en aplicaciones muy determinadas y como complemento a otros sistemas. 2.2.5 Aplicaciones del microscopio confocal [JDOB] [JMCU] Este avance en el campo de la microscopa nos posibilita el estudio tridimensional de las muestras, incluyendo su interior, e incluso, en el caso de determinados materiales, su reflexin. Otra de las aplicaciones de la Microscopia Confocal es el estudio de la localizacin de distintos marcadores en una regin concreta. Adems gracias a las caractersticas espectrales del equipo se consiguen excitar muestras en el rango del ultravioleta, estudiar las caractersticas de los espectros de emisin, eliminar o minimizar los tpicos problemas de solapamiento de espectros as como separar la emisin de los marcajes fluorescentes de la posible auto fluorescencia de la muestra. Tambin se pueden aplicar nuevas tcnicas como FRAP, FRET, FLIP, CAL. A continuacin mostramos algunas imgenes empleadas para biomedicina, tomadas con el microscopio confocal, empleando distintos tipos de marcajes.
10
Marta Garca Nuevo
Estado de la Tcnica
Figura 2.5: Imagen de barrido de un cultivo de clulas epiteliales Es capaz de mostrar con todo detalle levaduras, algas y protozoos, las bacterias slo son visualizadas en condiciones especiales de grandes aumentos pticos y electrnicos, perdiendo resolucin. A pesar de ello, se puede estudiar la condensacin del cromosoma bacteriano o el nmero de los mismos, mediante el uso de fluorocromos que se unen al DNA Por lo tanto, utilizando los fluorocromos adecuados se pueden estudiar los parmetros deseados. Por ejemplo, con levaduras se puede estudiar la posicin de las cicatrices de quitina, mediante primulina o calcofluor; se puede comprobar la situacin de los filamentos de actina y de los microtbulos; se pueden realizar cinticas de activacin mediante medida de la movilizacin del Ca intracelular, se pueden estudiar varios parmetros a la vez, como es la viabilidad, mediante IP y la cantidad de protena mediante FITC, se pueden comprobar las variaciones morfolgicas debidas a mutaciones especficas, etc.
Figura 2.6: E. Coliteidas con cloruro de propidio, para observar la condensacin del cromosoma. Dentro del campo de la infeccin, la microscopa confocal ha demostrado ser una herramienta eficaz al visualizar los microorganismos dentro de las clulas husped y la forma de interaccionar entre los dos organismos. En la actualidad se estn llevando a cabo, interesantes experimentos en esta rea.
11
Estado de la Tcnica
Marta Garca Nuevo
Figura 2.7: Visualizacin de un organismo en una clula husped.
2.2.6
Imgenes 3D con el microscopio confocal [ABEC]
Series de imgenes en dos dimensiones tomadas con el microscopio confocal, pueden ser combinadas para formar una imagen tridimensional. Esto es posible superponiendo las imgenes en dos dimensiones y creando los algoritmos adecuados para obtener los objetivos deseados, veremos algunos mtodos ms adelante. Una imagen en tres dimensiones puede ser vista en un computador como una proyeccin sobre uno de sus lados, una de sus secciones, o tambin como una animacin. Tenemos un ejemplo en las siguientes imgenes, que muestran las uniones entre dos tipos de clulas, vistas desde dos planos diferentes.
Figura 2.8: Dos tipos de clulas vistas en planos diferentes.
12
Marta Garca Nuevo
Estado de la Tcnica
2.2.7
Limitaciones de la microscopia confocal
Una de las limitaciones de la microscopa confocal es el tamao de los objetos que es capaz de visualizar. Es capaz de enfocar y obtener con nitidez imgenes muy pequeas. Las zonas que se encuentran cerca, las obtenemos borrosas y desenfocadas. Sobre estas zonas habr que aplicar procesamiento digital de imgenes, que es el siguiente punto del que trata el proyecto.
2.3 Eliminacin del ruido

Las imgenes digitales estn expuestas a diferentes tipos de ruidos, ya que hay diferentes formas de que el ruido se introduzca en una imagen, dependiendo de cmo haya sido creada. Con Matlab, y ms especficamente con la toolbox de Image Processing, tenemos distintos mtodos de eliminar o al menos reducir el ruido de las imgenes digitales. Para ello nos servimos de distintos mtodos segn el tipo de ruido. Tenemos varias formas de filtrado: Linear filtering, Median filtering, Adaptative filtering. 2.3.1 La imagen digital [AMAR]
La imagen digital se ha incorporado a la prctica totalidad de los equipos de microscopa electrnica y microscopa confocal y est sustituyendo rpidamente a las tradicionales cmaras fotogrficas en los microscopios pticos. Las ventajas de la imagen digital frente a la analgica vienen dadas por las mltiples posibilidades de manipulacin que nos ofrece. A una imagen digital se le puede cambiar el contraste, el brillo, el color; se puede combinar con otras imgenes; se puede duplicar, rotar , aumentar o disminuir; puede cuantificarse y puede transmitirse a miles de kms de distancia en pocos segundos. Para obtener una imagen que pueda ser tratada por el ordenador es preciso someter la imagen a un proceso de discretizacin tanto en las coordenadas como en la intensidad, a este proceso se le denomina digitalizacin. La digitalizacin consiste en la descomposicin de la imagen en una matriz de m*n puntos, donde cada punto tiene un valor proporcional a su color. Cada elemento en que se divide la imagen recibe el nombre de "pxel" (picture element). La resolucin espacial de la imagen viene dada por el nmero de pxeles que tiene la imagen. Cuanto mayor sea este nmero mayor va a ser la resolucin. La resolucin cromtica depende del nmero de bits que utilicemos para almacenar el valor de un pxel. Si utilizamos un bit podemos tener nicamente dos valores (0, 1) (blanco y negro), si utilizamos 4 bits el nmero posible de niveles de gris ser de 16 y si utilizamos 8 bits el nmero de niveles de gris posibles es de 256.
13
Estado de la Tcnica
Marta Garca Nuevo
En el caso de imgenes en color la intensidad puede considerarse como un vector tridimensional cuyas componentes son las intensidades en las tres bandas espectrales: rojo, verde y azul. Hablndose en este caso de una imagen multibanda, puesto que la informacin de la imagen color se desglosa en tres imgenes correspondientes a cada una de las bandas del espectro visible. Para cada una de las bandas se utilizan 8 bits de informacin, 24 bits en total , lo que nos dan ms de 16 millones de posibles combinaciones de colores. 2.3.2 Deconvolucin [CNBT]
La deconvolucin (Deconvolution = desenmaraamiento), es un trmino podramos traducir de modo ms general como "enfoque de imgenes sucias". Es una tcnica que permite restaurar una imagen borrosa y obtener de ella informacin adecuada. Aunque los algoritmos y programas que permiten aplicarla son conocidos desde hace mucho tiempo, fue la correccin digital de la "miopa" del telescopio espacial Hubbel con esta tcnica lo que permiti que un proyecto fracasado de millones de dolares pasase a tener la utilidad cientfica para la que se concibi: obtener imgenes de calidad. Gracias a este hecho la deconvolucin empez a valorarse como una herramienta de gran utilidad en la comunidad cientfica. Existe una creencia errnea de que un sistema de deconvolucin, es un sustituto de un microscopio confocal a menor coste y que las personas que usan deconvolucin, es por no tener suficiente presupuesto para un sistema confocal convencional. Este argumento no tiene sentido porque el precio del software ms el sistema informtico supera el coste de un microscopio confocal estndar. En realidad se trata de tcnicas complementarias: pueden solaparse en un 70 % de las aplicaciones pero cada una de ellas tiene un 30 % de aplicaciones que la otra no puede realizar. 2.3.3 Blind Deconvolucin [JCHI]
Blind Deconvolution es una tcnica que permite recuperar de una serie de imgenes borrosas otro conjunto de imgenes deconvueltas o enfocadas. El fundamento de la deconvolucin es una funcin matemtica: la funcin de la extensin de punto (PSF: point spread function) del sistema ptico donde se tomaron las imgenes. Existen tcnicas lineales y no lineales de deconvolucin pero en todas se necesita la PSF. Un sistema de deconvolucin consiste en un software especfico con un hardware muy potente que a travs de complicadas interacciones matemticas permite calcular cuales son los pxeles en foco y cuales no, removiendo de la imagen todo aquello que corresponda a zonas del objeto que estn fuera de foco. El sistema realiza por software una tarea equivalente al pinhole en un microscopio confocal motivo por el que a las tcnicas de deconvolucin se las conoce tambin como sistema confocal-digital.
14
Marta Garca Nuevo
Estado de la Tcnica
2.3.4
Debluring [TMAT]
Nuevos algoritmos fundamentales para enfocar imgenes borrosas. Entre estos algoritmos figuran Lucy-Richardson, deblurring regularizado y Wiener, cada uno de los cuales soporta problemas multidimensionales. Utilice las funciones de deconvolucin del conjunto de herramientas para restaurar las imgenes degradadas por el movimiento u otros factores. Para enfocar esta imagen de escala de grises de un fotgrafo se ha usado el algoritmo de Wiener, este es un tipo de filtro lineal, que se aplica sobre imgenes adaptativas. Este acta automticamente sobre la varianza, dando mayor o menor smothing. Esto suele producir mejores resultados que un filtro lineal normal. Este filtro adaptativo es ms selectivo conservando mejor los bordes y otras partes importantes de una imagen.
Figura 2.9: Ejemplo del tipo de filtrado, fotgrafo.
Aqu mostramos otro ejemplo del uso de la deconvolucin, algunas de las estrellas de la imagen de la izquierda estn ocultas por una regin brillante situada en el centro de la imagen. Esta regin brillante hace que la iluminacin de la imagen no sea uniforme. Dado que el fondo de la imagen es oscuro y los objetos son ms claros, la transformada morfolgica de proyeccin ascendente puede paliar la irregularidad de la iluminacin.
Figura 2.10: Ejemplo del tipo de filtrado, estrellas.
15
Estado de la Tcnica
Marta Garca Nuevo
Este filtro tambin requiere mayor capacidad computacional y ms tiempo que un filtro lineal, ya que hace implementaciones previas antes de mostrar el resultado. 2.3.5 Denoise
sta es la manera clsica de reducir el ruido aditivo en una imagen. El denoising se realiza en el dominio espacial
donde: F(u, v) : es el Fourier transforma de la imagen original (uncorrupted imagen) con m f como medio N(u, v) : es el Fourier transforma del ruido aditivo con m n como medio Una alternativa al filtro anterior, es un algoritmo usado aliasing al denoise una imagen. La puesta en prctica corresponde al diagrama siguiente:
El operador que alisa es el "filtro gaussian"que controla la fuerza del aliasing. El operador del umbral es un "suave thresholding" con un parmetro t del umbral ese los controles que los valores bajos se suprimen. Vemos un ejemplo de eliminacin del ruido de Image Processing Toolbox, para ello introducimos ruido y luego lo quitamos con tcnicas de filtrado. En la demos podemos ver cmo actan los distintos tipos de filtros
16
Marta Garca Nuevo
Estado de la Tcnica
Figura 2.11: Demo de la reduccin del ruido con Matlab.
2.3.6
Renderizacin
Es el proceso mediante el cual una estructura poligonal (tridimensional) digital obtiene una definicin mucho mayor. Esto se hace con juegos de luces, texturas y acentuado y mejorado de los polgonos, simulando ambientes y estructuras fsicas. Cuando se est trabajando en un programa profesional de diseo 3d por computadora, no se puede visualizar en tiempo real el resultado del diseo de un objeto o escena compleja ya que esto requiere una potencia de clculo extremadamente elevada, por lo que despus de disear el trabajo con una forma de visualizacin ms simple y tcnica, se realiza el proceso de renderizacin, tras el cual se puede apreciar el verdadero aspecto (aspecto final) de una imagen esttica o animacin. 2.3.7 Mtodos de renderizacin
Definimos rendering, en tratamiento de grficos por computadoras, como: Imagen tridimensional que incorpora la simulacin de efectos de iluminacin, tales como la sombra reflectiva. Un renderer es software y/o hardware que procesan datos de grficos, con objeto de visualizar, imprimir o exportar las figuras.
17
Estado de la Tcnica
Marta Garca Nuevo
Hay tres mtodos de renderizacin: OpenGL: librera de generacin de grficos tridimensionales, es compatible con casi todos los sistemas de computadoras. Este tipo de renderizacin es el ms rpido. Z-Buffer: Matlab dibuja rpidamente porque, los objetos son coloreados pxel a pxel, y solo se renderizan los pxeles visibles en la escena. Este mtodo puede consumir mucha memoria del sistema. Painters: Es el mtodo original de renderizacin en Matlab, es el ms rpido si la figura contiene solo objetos sencillos o pequeos. Los mtodos OpenGL y Z-buffer dibujan imgenes usando el mapa de bits (grficos raster). El mtodo Painters dibuja usando grficos de vectores, en general da resultados con mayor resolucin que los otros mtodos. Pero OpenGL y Z-buffer pueden trabajar en situaciones en las que Painters no produce buenos resultados o es incapaz de hacer nada.
2.3.8
Renderizacin en Matlab
Por defecto Matlab selecciona automticamente los mejores mtodos de renderizacin basndose en las caractersticas de las figuras y en algunas ocasiones el mtodo de impresin o el formato del archivo usado. En general, MATLAB usa: OpenGL para superficies complejas de los dibujos, usando interpolacin o juegos de luces. Z-buffer cuando la visualizacin de la imagen no es en el color real. Painter's para figuras de lneas, reas dibujos (grficos de barras, histogramas, etc...), y superficies sencillas. Usando los comandos de Matlab: Podemos seleccionar el tipo de renderizacin usando las propiedades de Renderer o el print command. Esto se hace de la siguiente manera, para Z-buffer. set(gcf, 'Renderer', 'zbuffer'); Salva el nuevo valor de Renderer con la figura.
18
Marta Garca Nuevo
Estado de la Tcnica
print zbuffer Afecta solo a la actual operacin. 2.3.9 Razones para cambiar la renderizacin
El mtodo de renderizacin usado para dibujar y exportar figuras, no es siempre el mismo que para visualizarlas. La razn ms importante para seleccionar la renderizacin despus de dibujar o exportar, es para hacer que la figura dibujada o exportada sea igual que la que se ve por pantalla. Otra razn para seleccionar la renderizacin, es para evitar que se exporte como bitmap en lugar de cmo formato vectorial. Cambia un formato bitmap a vectorial es un proceso largo. Si usamos uno de estos formatos y queremos estar seguros de que se guarda con formato vectorial, hay que elegir el mtodo de renderizacin Painters.
2.4 Aproximacin poligonal [CHEN] [CHXU]

Desde su aparicin, las tcnicas de adquisicin computarizada de imgenes mdicas constituyen una importante y potente herramienta de investigacin, porque permiten la exploracin de la anatoma humana y el diagnstico y tratamiento de enfermedades, sin necesidad de utilizar mtodos invasivos.
Figura 2.12: Ejemplo de aproximacin poligonal de una superficie.
Los volmenes de datos obtenidos por estas tcnicas, representan las caractersticas y relaciones entre las diversas estructuras orgnicas exploradas de la anatoma humana. Cada volumen de datos est compuesto por una secuencia de cortes o imgenes bidimensionales en tonos de gris, que pueden ser axiales o radiales dependiendo de la
19
Estado de la Tcnica
Marta Garca Nuevo
tcnica de adquisicin empleada. Los tonos de gris de las imgenes representan los diferentes niveles de densidad de los tejidos orgnicos examinados. Con la finalidad de auxiliar al especialista en la observacin e interpretacin de las imgenes mdicas, se dispone de un conjunto de tcnicas de visualizacin volumtrica, que utilizan la informacin contenida en los cortes que conforman los volmenes adquiridos de datos, para construir modelos geomtricos bidimensionales del objeto original. La finalidad es visualizar de forma interactiva estos modelos, mientras se aplican transformaciones visuales tales como rotaciones, traslaciones y escalamientos, que permitan una observacin precisa y detallada sin la necesidad de incurrir en los costos y riesgos que los mtodos quirrgicos convencionales suponen. Un primer enfoque para modelar la superficie consiste en ajustar un modelo matemtico descrito mediante su ecuacin matemtica implcita. Otro enfoque consiste en obtener el modelo geomtrico directamente del volumen de datos. En ambos casos el modelo geomtrico de la superficie se construye por aproximacin con parches poligonales utilizando algoritmos reconstructores de superficies tridimensionales, a partir de la informacin suministrada por la ecuacin implcita o directamente por los datos.
Figura 2.13: Modelado de una superficie.
El enfoque bsico que utilizan los algoritmos reconstructores de superficies, es el de recubrir con celdas cbicas el espacio que ocupa la superficie que se desea reconstruir, recorriendo progresiva y sistemticamente cada una de ellas para determinar cuales son
20
Marta Garca Nuevo
Estado de la Tcnica
intersectadas por la superficie. En el proceso de poligonizacin, para cada una de las celdas intersectadas se construye una aproximacin poligonal, por lo general representada por tringulos, de la superficie contenida en ellas. El conjunto final de todos los parches poligonales hallados constituye el modelo geomtrico tridimensional que aproxima a la superficie. En este trabajo se implementa una herramienta para el modelado geomtrico de superficies contenidas en volmenes de datos obtenidos con tcnicas de adquisicin de data mdica, tales como Resonancia Magntica Nuclear (RMN), Tomografa Axial Computarizada (TAC) y Ultrasonido (US). 2.4.1 Mtodos para realizar la aproximacin poligonal
La herramienta para construccin de mallados poligonales de volmenes y superficies implcitas primero construye el modelo geomtrico de una superficie descrita por su ecuacin matemtica implcita, y despus permite obtener mallados poligonales de superficies extradas de un volumen de datos a partir de un valor umbral de densidad.
Figura 2.14: Mallado de una superficie.
Las tareas principales del programa, son: Proceso de poligonizacin controlado por parmetros proporcionados por el usuario. Particin del espacio geomtrico de la superficie en celdas cbicas de resolucin fija, obtenidas por continuidad o por bsqueda exhaustiva. Deteccin automtica de superficies. Obtencin de valores de densidad mediante interpolacin trilineal.
21
Estado de la Tcnica
Marta Garca Nuevo
Obtencin de intersecciones mediante biseccin o interpolacin lineal. Almacenamiento cach de los valores evaluados de funciones y densidad. Obtencin de salida en formato de puntos-polgonos: una lista de vrtices puntos sobre la superficie) y una lista de tringulos que relacionan los vrtices entre s y definen el mallado poligonal. Transformaciones sobre los vrtices, tringulos y vectores normales. Almacenamiento de las listas de vrtices y tringulos en archivos de formatos grficos conocidos. 2.4.2 Esquema de continuidad y proceso de poligonalizacin.
La poligonizacin es un mtodo mediante el cual se obtiene una aproximacin poligonal a una superficie y consiste de dos etapas principales: proceso de particin espacial y proceso de clculo de intersecciones y generacin de polgonos. En el proceso de particin espacial por continuidad, la superficie de inters se recubre por celdas cbicas de resolucin fija. Para ello se recorre un camino aleatorio sobre el dominio de la funcin (continua o discreta), hasta que se encuentra un punto sobre la superficie. En este punto se ubica la primera celda cbica, y se sigue un procedimiento iterativo de bsqueda de nuevos cubos que corten a la superficie, ensayando con los cubos vecinos a las seis caras de cada cubo, hasta recubrir por completo toda la superficie. En las esquinas de cada celda se evala la funcin implcita; los valores negativos se consideran dentro de la superficie y los positivos fuera de la superficie. Cuando se utilizan volmenes de datos, los valores de las esquinas de las celdas son comparados con el valor umbral de densidad: los valores mayores que el umbral se consideran dentro de la superficie y los menores se consideran fuera de la superficie. Se genera un nuevo cubo adyacente a cada cara que Figura 2.15: Aproximacin de un contorno. contenga esquinas de signos opuestos o de configuracin adentro/afuera. En la siguiente etapa, se modelan mediante parches triangulares las intersecciones entre la superficie y la cscara de cubos encontrada, intersectando directamente los cubos, o descomponiendo cada cubo en seis tetraedros que luego son intersectados con la superficie para producir los parches triangulares. El segundo mtodo elimina los casos ambiguos que se presentan en la interseccin directa.
22
Marta Garca Nuevo
Estado de la Tcnica
Cada arista de la celda que conecta un par de esquinas adentro/afuera o positiva/negativa, contiene una interseccin con la superficie. Al unir entre s todos los vrtices sobre la superficie encontrados para una celda de poligonizacin, obtenemos los polgonos que aproximan la superficie. Los vectores normales a los vrtices de los tringulos se calculan por aproximacin al gradiente utilizando diferencias divididas centradas con respecto a dicho vrtice. El resultado final es un conjunto de parches triangulares que aproximan la superficie de inters. El conjunto de parches se describe en formato punto-polgono y est contenido en listas de vrtices y tringulos. Estas listas se almacenan en archivos de formatos grficos conocidos o son ledas directamente por la clase, sirviendo como entrada a un visualizador en OpenGL Para acelerar el proceso de particin espacial y poligonizacin, los valores de ndice de cubos, esquinas y puntos sobre la superficie son guardados en un cach organizado por tablas de hashing con dispersin abierta; de esta forma se evita recalcular cubos que ya fueron construidos y procesados, y evaluar la funcin implcita o interpolar redundantemente en los valores de esquinas y vrtices que ya fueron calculados.
Figura 2.16: Visualizacin de una figura obtenida por Aproximacin Poligonal.
2.4.3
Comentarios
Para obtener el modelo geomtrico de una superficie a partir de su ecuacin implcita o de un volumen de datos, deben manejarse un conjunto de parmetros proporcionados por el usuario. Estos parmetros, entre los cuales se encuentran la granularidad de la particin, tipo de poligonizacin y el valor umbral de densidad, determinan la exactitud y el tiempo de construccin del mallado, por lo cual debe experimentarse con ellos hasta lograr el resultado requerido o aceptable. La descomposicin en tetraedros produce una mayor cantidad de tringulos, y debido a esto toma ms tiempo el clculo del mallado, pero elimina las ambigedades que se presentan en algunos casos de la poligonizacin de celdas
23
Estado de la Tcnica
Marta Garca Nuevo
cbicas. Este factor tambin influye en el tiempo de rendering, puesto que al ser mayor el nmero de tringulos, toma ms tiempo la carga y despliegue del mallado. Tenemos entonces un compromiso detalle-precisin-tiempo al momento de elegir el valor de los parmetros.
2.5 Procesamiento distribuido [ENZO] [OPIN]

Un sistema distribuido es un conjunto de computadoras conectadas en red que le dan la sensacin al usuario de ser una sola computadora. Este tipo de sistema brinda una serie de ventajas, tales como: comparticin de recursos, la concurrencia, alta escalabilidad, y tolerancia a fallos. A pesar que agregar complejidad al software y disminuir los niveles de seguridad, los sistemas de procesamiento distribuidos brindan una buena relacin precio-desempeo y pueden aumentar su tamao de manera gradual al aumentar la carga de trabajo. Actualmente se est caminando desde los sistemas operativos en red a los sistemas distribuidos, aunque an no se han cumplido los objetivos de un sistema distribuido completamente tenemos ya algunos avances. Por ejemplo ya hay grandes avances en sistemas de ficheros para conseguir que exista un solo directorio raz al igual que la existencia de una ubicacin automtica por parte del sistema de los ficheros. Se puede implementar un balanceo de la capacidad y redundancia en los datos para minimizar el impacto de posibles cadas de nodos. 2.5.1 Ventajas del procesamiento distribuido Esta aproximacin tiene varias ventajas, por ejemplo en un sistema operativo distribuido se cumplen todas los criterios de transparencia, con todas las ventajas que esto supone, aparte tambin se tienen las siguientes ventajas: 1. Economa: la relacin precio rendimiento es mayor que en los sistemas centralizados sobretodo cuando lo que se buscan son altas prestaciones, los precios de los sistemas centralizados se disparan. 2. Velocidad: llega un momento en el que no se puede encontrar un sistema centralizado suficientemente potente, con los sistemas distribuidos siempre se podr encontrar un sistema ms potente uniendo esos mismos nodos. Se han hecho comparativas y los sistemas distribuidos especializados en cmputo han ganado a los mayores mainframes. 3. Distribucin de mquinas: podemos tener unas mquinas inherentemente distribuidas por el tipo de trabajo que realizan. 4. Alta disponibilidad: cuando una mquina falla no tiene que caer todo el sistema sino que este se recupera de las cadas y sigue funcionando con quizs algo menos de velocidad.
24
Marta Garca Nuevo
Estado de la Tcnica
5. Escalabilidad: puedes empezar un cluster con unas pocas mquinas y segn se descubre que la carga es elevada para el sistema, se aaden ms mquinas, no hace falta tirar las mquinas antiguas ni inversiones iniciales elevadas para tener mquinas suficientemente potentes. Ya se vi un ejemplo en su momento.
Figura 2.17: Sistemas distribuidos. Escalabilidad de servicios. 6. Comunicacin: los ordenadores necesariamente estn comunicados, para el correcto y eficaz funcionamiento del cluster se crean unas nuevas funcionalidad es avanzadas de comunicacin. Estas nuevas primitivas de comunicacin pueden ser usadas por los programas y por los usuarios para mejorar sus comunicaciones con otras mquinas. 7. Sistema de ficheros con raz nica: este sistema de ficheros hace que la administracin sea ms sencilla (no hay que administrar varios discos independientemente) y deja a cargo del sistema varias de las tareas. 8. Capacidad de comunicacin de procesos y de intercambio de datos universal: podemos enviar seales a cualquier procesos del cluster, as mismo podemos hacer trabajo conjunto con cualquier proceso e intercambiar con el datos, por lo tanto podramos tener a todos los procesos trabajando en un mismo trabajo. 2.5.2 Desventajas del procesamiento distribuido La principal desventaja de estos sistemas es la complejidad que implica su creacin. Bsicamente se tienen todos los problemas que se puedan tener en un nodo particular pero escalados. Vamos a ver los problemas que ocurren al intentar implantar las ventajas que hemos visto en el apartado anterior. Los puntos 1, 2 y 3 no tienen problemas de implantacin porque son inherentes a los sistemas distribuidos.
4.- Alta disponibilidad: podemos conseguir alta disponibilidad pues al tener varios nodos independientes, hay muchas menos posibilidades de que caigan todos a la vez. Pero esto por s slo no nos da alta disponibilidad. Tenemos que implantar los mecanismos necesarios para que cuando una mquina caiga, se sigan dando todos los servicios.
25
Estado de la Tcnica
Marta Garca Nuevo
Normalmente se apuesta por la replicacin de informacin. Si tenemos 3 servidores de ficheros, sirviendo los mismos ficheros, si uno de ellos cae podemos seguir obteniendo el servicio de alguno de los otros servidores (en el peor de los casos el servicio quizs se ralentice). Este caso adems ilustra otro problema que es la necesidad de actualizar todas las rplicas de un servicio: si un nodo escribe en uno de los servidores ste debe mandar los nuevos datos a los otros servidores para mantenerlos todos coherentes. De otro modo al caer uno de estos servidores perderamos toda la informacin que hubiramos ido grabando en este servidor y no en el resto. Tambin se tiene que disponer de los mecanismos adecuados para que el nodo que ve el fallo del servidor busque los servidores alternativos en busca de la informacin que necesita. Adems tambin se debe disponer de los mecanismos necesarios para que los nodos que han cado, cuando vuelvan a conectarse al cluster puedan continuar con su trabajo normalmente.
5.- Escalabilidad: el problema es que ms nodos suele implicar ms comunicacin, por lo que tenemos que disear un sistema lo ms escalable posible. Por ejemplo elegir una comunicacin todos con todos aunque tenga ciertas ventajas no es una solucin en absoluto escalable pues cada nuevo nodo tiene que comunicarse con todos los dems, lo que hace que incluir un nodo no sea lineal.
Una solucin para este problema son los clusters jerrquicos propuestos por Stephen Tweedie: clusters divididos en niveles. Un cluster como lo conocemos es un cluster de primer nivel, los nodos forman una lista de miembros. Hay un nodo privilegiado llamado lder. Para hacer clsteres ms grandes se juntan todos los lderes en un metacluster. Se crean entonces dos listas, una de ellas contiene todos los nodos llamada subcluster membership y la otra contiene nicamente los lderes llamada metacluster membership. Si se cambia de lder se cambia tambin en el metacluster. As podemos agrupar lderes de metaclusters en un cluster de tercer nivel, etc. Esta disposicin evita transiciones de todo el cluster, pues si hace falta aadir un nodo y crear una transicin en el cluster slo involucramos a los nodos de esa rama. Cuando el cluster necesite recuperacin habr nodos que participen y otros que no.
6.- Comunicacin: un cluster tiene ms necesidades de comunicacin que los sistemas normales por lo tanto tenemos que crear nuevos mtodos de comunicacin lo ms eficientes posibles. Un ejemplo de esto es Heartbeat. 7.-Sistemas de ficheros con raz nica: tenemos que independizar los sistemas de ficheros distintos de cada uno de los nodos para crear un sistema de ficheros general. Tenemos una fcil analoga con LVM, la cual abstrae al usuario de las particiones del disco duro y le hace ver un nico volumen lgico. Entre los problemas que nos encontramos en los sistemas de sabor UNIX se encuentran por ejemplo cmo manejar los directorios /proc y /dev. Hacer un solo directorio con ellos significara en /proc tener PIDs independientes para cada nodo,
26
Marta Garca Nuevo
Estado de la Tcnica
algo que no es tan complicado de conseguir y que tiene beneficios como que cada nodo sabe a ciencia cierta y sin ningn retardo cual es el siguiente PID que tiene que asignar. Pero adems incluye otra informacin como /proc/cpuinfo, /proc/meminfo, etc. que es especfica del nodo y que o se modifican esos ficheros para poner la informacin de todos los nodos en ellos (lo cual rompera la compatibilidad con algunas aplicaciones de usuario) o poner la informacin en directorios distintos que tuvieran como nombre el nmero del nodo (lo que traera la duda de qu informacin colocar en /proc). An peor es el caso de /dev pues aqu estn los dispositivos de cada nodo. Cuando los dispositivos de un nodo son totalmente distintos a los de otro no hay ningn problema (incluso poder acceder al dispositivo de otro nodo por este fichero sera perfecto) pero si todos los nodos tuvieran por ejemplo un disco duro IDE conectado en el primer slot como maestro con 3 particiones, tendramos repetidos en cada nodo hda1, hda2 y hda3; por lo tanto tendremos que tener un nuevo esquema para nombrar los dispositivos.
8.-Capacidad de comunicacin de procesos y de intercambio de datos universal: para conseguir este objetivo necesitamos una forma de distinguir unvocamente cada proceso del cluster. La forma ms sencilla es dando a cada proceso un PID nico, que llamaremos CPID (cluster process ID). Este CPID podra estar formado por el nmero de nodo y el nmero de proceso dentro de ese nodo. Una vez podemos direccionar con que proceso queremos comunicarnos, para enviar seales necesitaremos un sencillo mecanismo de comunicacin y seguramente el mismo sistema operativo en el otro extremo que entienda las seales. Para compartir datos, podemos enviarlos por la red o podemos crear memoria compartida a lo largo del cluster. Sobre como crear esta memoria compartida hablaremos en el captulo de sistemas operativos.
2.5.3 Transparencia Como se expone en el anterior apartado otras de las ventajas de los sistemas distribuidos es que cumple con todos los criterios de transparencia. Pero conseguir estos criterios implica ciertos mecanismos que debemos implementar: 1. Transparencia de acceso. Implica tener que mantener el viejo sistema para el nuevo cluster, por ejemplo mantener un rbol de directorios usual para manejar todos los dispositivos de almacenamiento del cluster. No tenemos que romper las APIs para introducir las nuevas funcionalidades. 2. Transparencia de localizacin. A nivel ms bajo tenemos que implantar una forma de conocer donde se encuentran los recursos, tradicionalmente se han usado servidores centralizados que lo saban todo, ahora ya se va consiguiendo que esta informacin se distribuya por la red. 3. Transparencia de concurrencia.
27
Estado de la Tcnica
Marta Garca Nuevo
Esto que no es excesivamente complicado en un sistema local, se ha convertido en un quebradero de cabeza en un sistema distribuido. Se han desarrollado varios mtodos para conseguirlo. El mayor problema es la desincronizacin de los relojes pues es muy complejo que todos los relojes hardware lleven exactamente la misma temporizacin por tanto algunos ordenadores ven los acontecimientos como futuros o pasados respecto a otros ordenadores. Este tema se tratar con ms profundidad en el captulo de sistemas operativos. 4. Transparencia de replicacin. Bsicamente el problema es que el sistema sepa que esas rplicas estn ahy mantenerlas coherentes y sincronizadas. Tambin tiene que activar los mecanismos necesarios cuando ocurra un error en un nodo. 5. Transparencia de fallos. Aunque haya fallos el sistema seguir funcionando. Las aplicaciones y los usuarios no sabrn nada de estos fallos o intentarn ser mnimamente afectados, como mucho, el sistema funcionar ms lentamente. Este punto est muy relacionado con la transparencia de replicacin. 6. Transparencia de migracin. Tenemos que solucionar problemas sobre las decisiones que tomamos para migrar un proceso, hay que tener en cuenta las polticas de migracin, ubicacin, etc. Adems tenemos que ver otros aspectos prcticos como si al nodo que vamos encontraremos los recursos que necesitamos, etc. La aplicacin no tiene que saber que fue migrada. 7. Transparencia para los usuarios. Implica una buena capa de software que de una apariencia similar a capas inferiores distintas. 8. Transparencia para programas. La ms compleja. Implica que los programas no tienen porque usar llamadas al sistema nuevas para tener ventaja del cluster. Mosix hace esto muy inteligentemente tomando la natural divisin en procesos de los programas para migrarlos de forma transparentemente. 2.5.4 Tendencia a lo distribuido Existen varios mtodos para intentar distribuir a nivel de aplicacin, son mtodos que abstraen las capas inferiores y hacen la vida ms fcil a los programadores de las aplicaciones, que no se tendrn que preocupar sobre las peculiaridades de las capas inferiores consiguindose una mayor efectividad en la programacin. Las tecnologas que se vern, en este orden, son:
28
Marta Garca Nuevo
Estado de la Tcnica
RPC: RMI: CORBA: Bonobo: KDE: SOAP: DCOM:
Remote Procedure Calls. Remote Method Invocation. Estndar de comunicacin de objetos. Abstraccin sobre CORBA de GNOME. Desktop Enviroment. Veremos: KIO, XMLRPC, DCOP. Simple Object Access Protocol. Tecnologa de Microsoft.
2.5.5 Migracin de procesos Migracin de procesos es mover el proceso desde donde originariamente se est ejecutando a un nuevo entorno. Aunque no se suela emplear en este caso, se podra hablar de migracin cuando un proceso se mueve de procesador. Aqu consideraremos migracin cuando un proceso se mueve de un nodo a otro. En un sistema de tipo cluster lo que se pretende, como se ver en el captulo de clusters, es compartir aquellas tareas para las que el sistema est diseado. Uno de los recursos que ms se deseara compartir, aparte del almacenamiento de datos, que es algo ya muy estudiado y por lo menos existen varias implementaciones, es el procesador de cada nodo. Para compartir el procesador entre varios nodos, lo ms lgico es permitir que las unidades atmicas de ejecucin del sistema operativo sean capaces de ocupar en cualquier momento cualesquiera de los nodos que conforman el cluster. A ese paso de un nodo a otro de un proceso se le llama migracin del proceso. En un sistema multiprogramable y multiusuario de tiempo compartido, la eleccin de qu proceso se ejecuta en un intervalo de tiempo determinado, la hace un segmento de cdigo que recibe el nombre de scheduler u planificador. Una vez que el scheduler se encarga de localizar un proceso con las caractersticas adecuadas para comenzar su ejecucin, es otra seccin de cdigo llamada dispatcher la que se encarga de sustituir el contexto de ejecucin en el que se encuentre el procesador, por el contexto del proceso que queremos correr. Las cosas se pueden complicar cuando tratamos de ver este esquema en un multicomputador. En un cluster, se pueden tener varios esquemas de actuacin. Para saber cundo se debe realizar una migracin nuestro nodo debe estar en contacto con los dems nodos y recolectar informacin sobre su estado y as, y teniendo en cuenta otros parmetros como la carga de la red, se debe hacer una decisin lo ms inteligente posible y decidir si es momento de migrar y qu es lo que se migra. Las causas que hacen que se quiera realizar la migracin van a depender del objetivo del servicio de la migracin. As si el objetivo es maximizar el tiempo usado de procesador, lo que har que un proceso migre es el requerimiento de procesador en su nodo local, as gracias a la informacin que ha recogido de los dems nodos decidir si los merece la pena migrar o en cambio los dems nodos estn sobrecargados tambin.
29
Estado de la Tcnica
Marta Garca Nuevo
La migracin podra estar controlada por un organismo central que tuviera toda la informacin de todos los nodos actualizada y se dedicase a decidir como colocar los procesos de los distintos nodos para mejorar el rendimiento, esta solucin aparte de ser poco escalable pues se sobrecargan mucho la red de las comunicaciones y estamos sobrecargando uno de los equipos, su mayor error es que si este sistema falla se dejarn de migrar los procesos. El otro mecanismo es una toma de decisiones distribuida, cada nodo tomar sus propias decisiones usando su poltica de migracin asignada. Dentro de esta aproximacin hay dos entidades que pueden decidir cuando emigrar: el proceso o el kernel. Si el proceso es quien va a decidirlo tenemos el problema de que el proceso tiene que ser consciente de la existencia de un sistema distribuido. En cambio si es el kernel quin decide tenemos la ventaja de que la funcin de migracin y la existencia de un sistema distribuido puede ser transparente al proceso. Esta es la poltica que usa OpenMosix. 2.5.6 Comunicacin entre procesos En un cluster existe un nuevo problema, si movemos un proceso y lo movemos a otro nodo, ese proceso debe seguir pudiendo comunicarse con los dems procesos sin problemas, por lo que necesitamos enviar las seales que antes eran locales al nodo a travs de la red. Por tanto cada sistema tiene sus propias primitivas de comunicacin para enviar toda la comunicacin a travs de la red. Hay mecanismos de comunicacin ms problemticos que otros, por ejemplo las seales no son demasiado problemticas pues se puede encapsular en un paquete qu se enve a travs de la red y el sistema destino coge el paquete, saca la informacin de que proceso emiti la seal, que seal fue y a qu proceso se emite y ya se tiene una forma global de enviar seales. El nico problema es que implicara que el sistema debe saber en todo momento el nodo dnde est el proceso con el que quiere comunicar o hacer una comunicacin broadcast a todos los nodos para enviar una sola seal. Otros mecanismos de comunicacin entre procesos son ms complejos de implementar, por ejemplo la memoria compartida, se necesita tener memoria distribuida y poder compartir esa memoria distribuida. Los sockets como el caso de la familia Unix, tambin son candidatos difciles a migrar por la relacin que tienen los servidores con el nodo. Para migrar estas interacciones entre procesos de manera elegante y eficiente se necesita un sistema especialmente diseado para ello, por ejemplo del tipo SSI de Compaq. 2.5.7 Entrada salida En un sistema tradicional, la entrada/salida es local al nodo en el que se produce, pero desde la aparicin de las redes se han venido aprovechando stas para acceder a determinados recursos de entrada/salida colocados en un ordenador distante. Por ejemplo es tpico en las empresas comprar una nica impresora cara para obtener la mejor calidad posible y dejar que esa impresora sea accedida desde cualquier ordenador de la intranet de la empresa, aunque esto significa el desplazamiento fsico de los empleados, puede ser un ahorro considerable a instalar una impresora en cada uno de los ordenadores. Otro ejemplo muy comn es NFS que permite centralizar los accesos al sistema de ficheros, podemos
30
Marta Garca Nuevo
Estado de la Tcnica
disponer de ordenadores sin discos duros o permitimos que todo el trabajo se actualice en un solo lugar. El problema es que para estos dos ejemplos se han desarrollado soluciones especficas que necesitan un demonio escuchando peticiones en un determinado puerto y en el caso de NFS algn cambio en los sistemas de ficheros. Pero desarrollar una solucin general es mucho ms complejo y quizs incluso no deseable. Para que cualquier nodo pueda acceder a cualquier recurso de entrada/salida, primero se necesita una sincronizacin que como ya vimos en una seccin anterior de este captulo puede llegar a ser complejo. Pero tambin se necesitan otras cosas como conocer los recursos de entrada/salida de los que se dispone, una forma de nombrarlos de forma nica a travs del cluster etc. Para el caso concreto de migracin de procesos el acceso a entrada y salida puede evitar que un proceso en concreto migre o ms convenientemente los procesos deberan migrar al nodo donde estn realizando toda su entrada/salida para evitar que todos los datos a los que estn accediendo tengan que viajar por la red. As por ejemplo un proceso en OpenMosix que est muy vinculado al hardware de entrada/salida no migrar nunca (X, lpd, etc.). Los sockets como caso especial de entrada y salida tambin plantean muchos problemas porque hay servicios que estn escuchando un determinado puerto en un determinado ordenador para los que migrar sera catastrfico pues no se encontraran los servicios disponibles para los ordenadores que accediera n a ese nodo en busca del servicio. Hay gente que apoya el SSI en la que todos los nodos ven el mismo sistema y que no importa donde estn los recursos o los programas porque se acceden a ellos siempre correctamente, esto significara que los sockets podran migrar porque realmente no importa donde est el servicio para acceder a l.
2.5.8
Clusters [OPIN] [KHWA] [SGAL]
Aunque parezca sencillo de responder a la pregunta, qu es un cluster? no lo es en absoluto. Podra incluirse alguna definicin de algn libro pero el problema es que ni los expertos en clusters, ni la gente que los implementa se ponen de acuerdo en qu es aquello en lo que trabajan. Muy vagamente un cluster podemos entenderlo como: Un conjunto de mquinas unidas por una red de comunicacin trabajando por un objetivo conjunto. Segn el tipo puede ser dar alta disponibilidad, alto rendimiento etc... Por poner unos ejemplos de la disparidad de opiniones que existen se adjuntan las definiciones que dan ciertas autoridades de esta materia: `Ùn cluster consiste en un conjunto de mquinas y un servidor de cluster dedicado, para realizar los relativamente infrecuentes accesos a los recursos de otros procesos, se accede al servidor de cluster de cada grupo'' del libro Operating System Concepts de Silberschatz Galvin.
31
Estado de la Tcnica
Marta Garca Nuevo
`Ùn cluster es la variacin de bajo precio de un multiprocesador masivamente paralelo (miles de procesadores, memoria distribuida, red de baja latencia), con las siguientes diferencias: cada nodo es una mquina quizs sin algo del hardware (monitor, teclado, mouse, etc.), el nodo podra ser SMP o PC. Los nodos se conectan por una red de bajo precio como Ethernet o ATM aunque en clusters comerciales se pueden usar tecnologas de red propias. El interfaz de red no est muy acoplado al bus I/O. Todos los nodos tienen disco local. Cada nodo tiene un sistema operativo UNIX con una capa de software para soportar todas las caractersticas del cluster'' del libro Scalable Parallel Computing de Kai Hwang y Khiwei Xu. `Ès una clase de arquitectura de computador paralelo que se basa en unir mquinas independientes cooperativas integradas por medio de redes de interconexin, para proveer un sistema coordinado, capaz de procesar una carga'' del autor Dr. Thomas Sterling. Como se puede apreciar cada una de las definiciones difiere de las dems llegando incluso a contradecirse. 2.5.8.1 Caractersticas de los cluster Si no hay acuerdo sobre lo que es un cluster poco podr acertarse en sus caractersticas. En este apartado se explican los requisitos que deben cumplir un conjunto de computadoras para ser consideradas cluster, tal y como se conocen hasta el momento. Para crear un cluster se necesitan al menos dos nodos. Una de las caractersticas principales de estas arquitecturas es que exista un medio de comunicacin (red) donde los procesos puedan migrar para computarse en diferentes estaciones paralelamente. Un solo nodo no cumple este requerimiento por su condicin de aislamiento para poder compartir informacin. Las arquitecturas con varios procesadores en placa tampoco son consideradas clusters, bien sean mquinas SMP o mainframes debido a que el bus de comunicacin no suele ser de red, sino interno. Por esta razn se deduce la primera caracterstica de un cluster: a.) Un cluster consta de 2 o ms nodos. Como hemos visto los nodos necesitan estar conectados para llevar a cabo su misin, de nada nos sirven 10 ordenadores que no se pueden traspasar informacin. Por tanto la segunda caracterstica queda como: b.) Los nodos de un cluster estn conectados entre s por un canal de comunicacin funcional.
32
Marta Garca Nuevo
Estado de la Tcnica
Por ahora hemos hablado de las caractersticas fsicas de un cluster, que son las caractersticas sobre las que ms consenso hay. Pero existen ms problemas sobre las caractersticas del programa que se ejecuta sobre los mismos, pues es el software el que finalmente dotar al conjunto de mquinas de capacidad para migrar procesos, balancear la carga en cada nodo, etc. c.) Los clsteres necesitan software especializado. El problema tambin se plantea por los distintos tipos de clusters, cada uno de ellos requiere un modelado y diseo del software distinto. Se dan casos de programas que efectan el trabajo de un cluster, pero que por el contrario son consideradas como aplicaciones individuales sin ningn tipo de conexin, que se comportan de manera organizada por eventos de cada nodo, como podra ser un sistema realizado a base de llamadas rexec solicitadas a cada nodo. Como es obvio la funcionalidad las caractersticas del cluster son completamente dependientes del software, por lo que no entraremos en las funcionalidades del software de momento, sino, en el modelo general de software que compone un cluster. Para empezar, parte de este software se debe dedicar a la comunicacin entre los nodos. Existen varios tipos de software que pueden conformar un cluster:
Software a nivel de aplicacin, software generado por bibliotecas especiales dedicadas a clusters.
o
Este tipo de software se sita a nivel de aplicacin, se utilizan generalmente bibliotecas de carcter general que permiten la abstraccin de un nodo a un sistema conjunto, permitiendo crear aplicaciones en un entorno distribuido de manera lo ms abstracta posible. Este tipo de software suele generar elementos de proceso del tipo rutinas, procesos o tareas, que se ejecutan en cada nodo del cluster y se comunican entre s a travs de la red.
Software a nivel de sistema.

o
Este tipo de software se sita a nivel de sistema, suele estar implementado como parte del sistema operativo de cada nodo, o ser la totalidad de este. Es ms crtico y complejo, por otro lado suele resolver problemas de carcter ms general que los anteriores y su eficiencia, por norma general, es mayor.
A pesar de la categorizacin de este software, existen casos en los cuales se hace uso de un conjunto de piezas de software de cada tipo para conformar un sistema cluster completo. Es decir, un cluster puede tener implementado a nivel de kernel parte del sistema y otra parte estar preparada a nivel de usuario.
33
Estado de la Tcnica
Marta Garca Nuevo
Figura 2.18: Cluster a nivel de sistema y nivel de aplicacin
2.5.9 Clustering con OpenMosix La mayor parte del tiempo tu computadora permanece ociosa. Si lanzas un programa de monitorizacin del sistema como xload o top, vers probablemente que la lectura de la carga de tu procesador permanece generalmente por debajo del 10%. Si tienes al alcance varias computadoras los resultados sern los mismos ya que no podrs interactuar con ms de una de ellas al mismo tiempo. Desafortunadamente cuando realmente necesites potencia computacional (como por ejemplo para comprimir un fichero Ogg Vorbis, o para una gran compilacin) no podrs disponer de la potencia conjunta que te proporcionaran todas ellas como un todo. La idea que se esconde en el trasfondo del clustering es precisamente poder contar con todos los recursos que puedan brindarte el conjunto de computadoras de que puedas
34
Marta Garca Nuevo
Estado de la Tcnica
disponer para poder aprovechar aquellos que permanecen sin usar, bsicamente en otras computadoras. La unidad bsica de un cluster es una computadora simple, tambin denominada nodo. Los clusters pueden crecer en tamao (o mejor dicho, pueden escalar) aadiendo ms mquinas. Un cluster como un todo puede ser ms potente que la ms veloz de las mquinas con las que cuenta, factor que estar ligado irremediablemente a la velocidad de conexin con la que hemos construido las comunicaciones entre nodos. Adems, el sistema operativo del cluster puede hacer un mejor uso del hardware disponible en respuesta al cambio de condiciones. Esto produce un reto a un cluster heterogneo (compuesto por mquinas de diferente arquitectura) tal como se ir viendo en este proyecto. OpenMosix es un parche (patch) para el kernel de Linux que proporciona compatibilidad completa con el estndar de Linux para plataformas IA32. Actualmente se est trabajando para portarlo a IA64.
Figura 2.19: Logo de OpenMosix El algoritmo interno de balanceo de carga migra, transparentemente para el usuario, los procesos entre los nodos del cluster. La principal ventaja es una mejor comparticin de recursos entre nodos, as como un mejor aprovechamiento de los mismos. El cluster escoge por s mismo la utilizacin ptima de los recursos que son necesarios en cada momento, y de forma automtica. Esta caracterstica de migracin transparente hace que el cluster funcione a todos los efectos como un gran sistema SMP (Symmetric Multi Processing) con varios procesadores disponibles. Su estabilidad ha sido ampliamente probada aunque todava se est trabajando en diversas lneas para aumentar su eficiencia. OpenMosix est respaldado y siendo desarrollado por personas muy competentes y respetadas en el mundo del open source, trabajando juntas en todo el mundo. El punto fuerte de este proyecto es que intenta crear un estndar en el entorno del clustering para todo tipo de aplicaciones HPC.
35
Estado de la Tcnica
Marta Garca Nuevo
Los clusters OpenMosix pueden adoptar varias formas. Para demostrarlo intentad imaginar que compartes el piso de estudiante con un chico adinerado que estudia ciencias de la computacin. Imaginad tambin que tenis las computadoras conectadas en red para formar un cluster OpenMosix. Asume tambin que te encuentras convirtiendo ficheros de msica desde tus CDs de audio a Ogg Vorbis para tu uso privado, cosa que resulta ser legal en tu pas. Tu compaero de habitacin se encuentra trabajando en un proyecto de C++ que segn dice podr traer la paz mundial, pero en este justo momento est en el servicio cantando cosas ininteligibles, y evidentemente su computadora est a la espera de ser intervenida de nuevo. Resulta que cuando inicias un programa de compresin, como puede ser bladeenc para convertir un preludio de Bach desde el fichero .wav al .ogg, las rutinas de OpenMosix en tu mquina comparan la carga de procesos en tu mquina y en la de tu compaero y deciden que es mejor migrar las tareas de compresin ya que el otro nodo es ms potente debido a que el chico dispona de ms medios econmicos para poderse permitir una computadora ms potente, a la vez que en ese momento permanece ociosa ya que no se encuentra frente a ella. As pues lo que normalmente en un Pentium 233 tardara varios minutos te das cuenta que ha terminado en pocos segundos. Lo que ha ocurrido es que gran parte de la tarea ha sido ejecutada en el AMD Athlon XP de tu compaero, de forma transparente a ti. Minutos despus te encuentras escribiendo y tu compaero de habitacin vuelve del servicio. ste reanuda sus pruebas de compilacin utilizando pmake, una versin del make optimizada para arquitecturas paralelas. Te das cuenta que OpenMosix est migrando hacia tu mquina algunos subprocesos con el fin de equilibrar la carga. Esta configuracin se llama single-pool: todas las computadoras estn dispuestas como un nico cluster. La ventaja o desventaja de esta disposicin es que tu computadora es parte del pool: tus procesos sern ejecutados, al menos en parte, en otras computadoras, pudiendo atentar contra tu privacidad de datos. Evidentemente las tareas de los dems tambin podrn ser ejecutadas en la tuya. 2.5.9.1 Caractersticas de OpenMosix Pros de OpenMosix No se requieren paquetes extra No son necesarias modificaciones en el cdigo Figura 2.20: Logo de Linux
36
Marta Garca Nuevo
Estado de la Tcnica
Contras de OpenMosix Es dependiente del kernel No migra todos los procesos siempre, tiene limitaciones de funcionamiento Problemas con memoria compartida Adems los procesos con mltiples threads no ganan demasiada eficiencia Tampoco se obtendr mucha mejora cuando se ejecute un solo proceso, como por ejemplo el navegador. Subsistemas de OpenMosix Actualmente podemos dividir los parches de OpenMosix dentro del kernel en cuatro grandes subsistemas, vemoslos. a.) Mosix File System (MFS) El primer y mayor subsistema (en cuanto a lneas de cdigo) es MFS que te permite un acceso a sistemas de ficheros (FS) remotos (i.e. de cualquier otro nodo) si est localmente montado. El sistema de ficheros de tu nodo y de los dems podrn ser montados en el directorio /mfs y de esta forma se podr, por ejemplo, acceder al directorio /home del nodo 3 dentro del directorio /mfs/3/home desde cualquier nodo del cluster. Figura 2.21: Logo de Linux b.) Migracin de procesos Con OpenMosix se puede lanzar un proceso en una computadora y ver 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 significa 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 raz. OpenMosix se encargar de establecer la comunicacin entre estos 2 procesos.
37
Estado de la Tcnica
Marta Garca Nuevo
c.) Direct File System Access (DFSA) OpenMosix proporciona MFS con la opcin DFSA que permite acceso a todos los sistemas de ficheros, tanto locales como remotos. Para ms informacin dirgase a la seccin de Sistema de ficheros de las FAQs (preguntas ms frecuentes) del presente documento. d.) Memory ushering Este subsistema se encarga de migrar las tareas que superan la memoria disponible en el nodo en el que se ejecutan. Las tareas que superan dicho lmite se migran forzosamente a un nodo destino de entre los nodos del cluster que tengan suficiente memoria como para ejecutar el proceso sin necesidad de hacer swap a disco, ahorrando as la gran prdida de rendimiento que esto supone. El subsistema de memory ushering es un subsistema independiente del subsistema de equilibrado de carga, y por ello se le considera por separado. El algoritmo de migracin De entre las propiedades compartidas entre Mosix y OpenMosix podemos destacar el mecanismo de migracin, en el que puede migrar-se cualquiera proceso a cualquier nodo del cluster de forma completamente transparente al proceso migrado. La migracin tambin puede ser automtica: el algoritmo que lo implementa tiene una complejidad computacional del orden de O(n), siendo n el nmero de nodos del cluster. Para implementarlo OpenMosix utiliza el modelo fork-and-forget, desarrollado en un principio dentro de Mosix para mquinas PDP11/45 empleadas en las fuerzas areas norteamericanas. 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, y las tareas que se estn ejecutando puedan migrar a cualquier otro nodo del cluster. As desde que se ejecuta una tarea hasta que sta muere, podr migrar de un nodo a otro, sin que el proceso sufra mayores cambios. Podramos pensar que el comportamiento de un cluster OpenMosix es como una mquina NUMA, aunque estos clusters son mucho ms baratos. El nodo raz Cada proceso ejecutado en el cluster tiene un nico nodo raz, como se ha visto. El nodo raz es el nodo en el cual se lanza originalmente el proceso y donde ste empieza a ejecutarse. Desde el punto de vista del espacio de procesos de las mquinas del cluster, cada proceso (con su correspondiente PID) parece ejecutarse en su nodo raz. El nodo de ejecucin puede ser el nodo raz u otro diferente, hecho que da lugar a que el proceso no
38
Marta Garca Nuevo
Estado de la Tcnica
use un PID del nodo de ejecucin, sino que el proceso migrado se ejecutar en ste como una hebra del kernel. La interaccin con un proceso, por ejemplo enviarle seales desde cualquier otro proceso migrado, se puede realizar exclusivamente desde el nodo raz. El usuario que ejecuta un proceso en el cluster ha accedido al cluster desde el nodo raz del proceso. El propietario del proceso en cuestin tendr control en todo momento del mismo como si se ejecutara localmente. Por otra parte la migracin y el retorno al nodo raz de un proceso se puede realizar tanto desde el nodo raz como desde el nodo dnde se ejecuta el proceso. Esta tarea la puede llevar a trmino el administrador de cualquiera de los dos sistemas. El mecanismo de migrado La migracin de procesos en OpenMosix es completamente transparente. Esto significa que al proceso migrado no se le avisa de que ya no se ejecuta en su nodo de origen. Es ms, este proceso migrado seguir ejecutndose como si siguiera en el nodo origen: si escribiera o leyera al disco, lo hara en el nodo origen, hecho que supone leer o grabar remotamente en este nodo. Cundo podr migrar un proceso? Desgraciadamente, no todos los procesos pueden migrar en cualquiera circunstancia. El mecanismo de migracin de procesos puede operar sobre cualquier tarea de un nodo sobre el que se cumplen algunas condiciones predeterminadas. stas son:

el proceso no puede ejecutarse en modo de emulacin VM86 el proceso no puede ejecutar instrucciones en ensamblador propias de la mquina donde se lanza y que no tiene la mquina destino (en un cluster heterogneo) el proceso no puede mapear memoria de un dispositivo a la RAM, ni acceder directamente a los registros de un dispositivo el proceso no puede usar segmentos de memoria compartida
Cumpliendo todas estas condiciones el proceso puede migrar y ejecutarse migrado. No obstante, como podemos sospechar, OpenMosix no adivina nada. OpenMosix no sabe a priori si alguno de los procesos que pueden migrar tendrn algunos de estos problemas. Por esto en un principio OpenMosix migra todos los procesos que puedan hacerlo si por el momento cumplen todas las condiciones, y en caso de que algn proceso deje de cumplirlas, lo devuelve de nuevo a su nodo raz para que se ejecute en l mientras no pueda migrar de nuevo. Todo esto significa que mientras el proceso est en modo de emulacin VM86, mapee memoria de un dispositivo RAM, acceda a un registro o tenga reservado/bloqueado
39
Estado de la Tcnica
Marta Garca Nuevo
un puntero a un segmento de memoria compartida, el proceso se ejecutar en el nodo raz, y cuando acabe la condicin que lo bloquea volver a migrar. Con el uso de instrucciones asociadas a procesadores no compatibles entre ellos, OpenMosix tiene un comportamiento diferente: solo permitir migrar a los procesadores que tengan la misma arquitectura. La comunicacin entre las dos reas Un aspecto importante en el que podemos tener inters es en cmo se realiza la comunicacin entre el rea de usuario y el rea de kernel. En algn momento, el proceso migrado puede necesitar hacer alguna llamada al sistema. Esta llamada se captura y se evala

si puede ser ejecutada al nodo al que la tarea ha migrado, o si necesita ser lanzada en el nodo raz del proceso migrado
Si la llamada puede ser lanzada al nodo dnde la tarea migrada se ejecuta, los accesos al kernel se hacen de forma local, es decir, que se atiende en el nodo dnde la tarea se ejecuta sin ninguna carga adicional a la red. Por desgracia, las llamadas ms comunes son las que se han de ejecutar forzosamente al nodo raz, puesto que hablan con el hardware. Es el caso, por ejemplo, de una lectura o una escritura a disco. En este caso el subsistema de OpenMosix del nodo dnde se ejecuta la tarea contacta con el subsistema de OpenMosix del nodo raz. Para enviarle la peticin, as como todos los parmetros y los datos del nodo raz que necesitar procesar. El nodo raz procesar la llamada y enviar de vuelta al nodo dnde se est ejecutando realmente el proceso migrado:

el valor del xito/fracaso de la llamada aquello que necesite saber para actualizar sus segmentos de datos, de pila y de heap el estado en el que estara si se estuviera ejecutando el proceso al nodo raz
Esta comunicacin tambin puede ser generada por el nodo raz. Es el caso, por ejemplo, del envo de una seal. El subsistema de OpenMosix del nodo raz contacta con el subsistema de OpenMosix del nodo dnde el proceso migrado se ejecuta, y el avisa que ha ocurrido un evento asncrono. El subsistema de OpenMosix del nodo dnde el proceso migrado se ejecuta parar el proceso migrado y el nodo raz podr empezar a atender el cdigo del rea del kernel que correspondera a la seal asncrona.
40
Marta Garca Nuevo
Estado de la Tcnica
Finalmente, una vez realizada toda el operativa necesaria de la rea del kernel, el subsistema de OpenMosix del nodo raz del proceso enva al nodo donde est ejecutndose realmente el proceso migrado el aviso detallado de la llamada, y todo aquello que el proceso necesita saber (anteriormente enumerado) cuando recibi la seal, y el proceso migrado finalmente recuperar el control. Por todo esto el proceso migrado es como s estuviera al nodo raz y hubiera recibido la seal de ste. Tenemos un escenario muy simple donde el proceso se suspende esperando un recurso. Recordemos que la suspensin esperando un recurso se produce nicamente en rea de kernel. Cuando se pide una pgina de disco o se espera un paquete de red se resuelto como en el primero caso comentado, es decir, como un llamada al kernel. Este mecanismo de comunicacin entre reas es el que nos asegura que
la migracin sea completamente transparente tanto para el proceso que migra como para los procesos que cohabiten con el nodo raz que el proceso no necesite ser reescrito para poder migrar, ni sea necesario conocer la topologia del cluster para escribir una aplicacin paralela
No obstante, en el caso de llamadas al kernel que tengan que ser enviadas forzosamente al nodo raz, tendremos una sobrecarga adicional a la red debida a la transmisin constante de las llamadas al kernel y la recepcin de sus valores de vuelta. Destacamos especialmente esta sobrecarga en el acceso a sockets y el acceso a disco duro, que son las dos operaciones ms importantes que se habrn de ejecutar en el nodo raz y suponen una sobrecarga al proceso de comunicacin entre la rea de usuario migrada y la rea de kernel del proceso migrado. 2.5.10 Clustering con MPI (ParaView) [ACAL] MPI es una estndar creado por un amplio comit 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 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 desarrollos, pero no en sus principios bsicos. Existen actualmente diferentes implementaciones de MPI, algunas son comerciales y otras son gratis y portables a mltiples arquitecturas. En nuestras prcticas trabajaremos con LAM (Local Area Multicomputer) que es un ambiente de desarrollo y programacin de MPI orientado a arquitecturas heterogneas de ordenadores distribuidos en una red local. Con LAM tanto un "cluster" dedicado como un una simple red local de ordenadores puede actuar como un ordenador multiprocesador.
41
Estado de la Tcnica
Marta Garca Nuevo
MPI [7] es una interfaz estndar de paso de mensajes cuyos objetivos bsicos son: la funcionalidad, la eficiencia y la portabilidad. Aunque la semntica que especifica MPI para el paso de mensajes permite su utilizacin en aplicaciones y entornos multithread, en la actualidad no existe ninguna implementacin de este estndar que verdaderamente pueda ser utilizada para desarrollar un programa MPI multithread. El uso de threads en una aplicacin que emplea paso de mensajes y la implementacin de un sistema de paso de mensajes utilizando threads puede ser muy til por varias razones: o Los threads permiten una implementacin natural de operaciones no bloqueantes, basta con crear un thread que procese la operacin no bloqueante. El uso de threads puede incrementar la eficiencia de la implementacin de operaciones colectivas. Los threads ofrecen un modelo natural para implementar ciertas operaciones que requieren memoria compartida. En general todo proceso que emplea paso de mensajes para comunicarse con otros, lleva a cabo dos tareas bien diferenciadas, una de cmputo y otra de intercambio de mensajes. Estas tareas pueden implementarse de forma eficiente utilizando threads dentro del mismo proceso. Los threads se estn convirtiendo en el mecanismo de programacin paralela de los multiprocesadores de memoria compartida, ya que permiten explotar el paralelismo de dichas arquitecturas de una forma eficiente.
A continuacin se describen algunas de las principales caractersticas que ofrece MPI: Operaciones colectivas. Una operacin colectiva es una operacin ejecutada por todos los procesos que intervienen en un clculo o comunicacin. En MPI existen dos tipos de operaciones colectivas: operaciones de movimiento de datos y operaciones de clculo colectivo. Las primeras se utilizan para intercambiar y reordenar datos entre un conjunto de procesos. Un ejemplo tpico de operacin colectiva es la difusin (broadcast) de un mensaje entre varios procesos. Las segundas permiten realizar clculos colectivos como mnimo, mximo, suma, OR lgico, etc, as como operaciones definidas por el usuario. Topologas virtuales, ofrecen un mecanismo de alto nivel para manejar grupos de procesos sin tratar con ellos directamente. MPI soporta grafos y redes de procesos. Modos de comunicacin. MPI soporta operaciones bloqueantes, no bloqueantes o asncronas y sncronas. Una operacin de envo bloqueante bloquea al proceso que la ejecuta slo hasta que el buffer pueda ser reutilizado de nuevo. Una operacin no
42
Marta Garca Nuevo
Estado de la Tcnica
bloqueante permite solapar el clculo con las comunicaciones. En MPI es posible esperar por la finalizacin de varias operaciones no bloqueantes. Un envo sncrono bloquea la operacin hasta que la correspondiente recepcin tiene lugar. En este sentido, una operacin bloqueante no tiene por que ser sncrona. Soporte para redes heterogneas. Los programas MPI estn pensados para poder ejecutarse sobre redes de mquinas heterogneas con formatos y tamaos de los tipos de datos elementales totalmente diferentes. Tipos de datos. MPI ofrece un amplio conjunto de tipos de datos predefinidos (caracteres, enteros, nmeros en coma flotante, etc.) y ofrece la posibilidad de definir tipos de datos derivados. Un tipo de datos derivado es un objeto que se construye a partir de tipos de datos ya existentes. En general, un tipo de datos derivado se especifica como una secuencia de tipos de datos ya existentes y desplazamientos (en bytes) de cada uno de estos tipos de datos. Estos desplazamientos son relativos al buffer que describe el tipo de datos derivado. Modos de programacin. Con MPI se pueden desarrollar aplicaciones paralelas que sigan el modelo SPMD o MPMP. Adems el interfaz MPI tiene una semntica multithread (MT-safe), que le hace adecuado para ser utilizado en programas MPI y entornos multithread.
_
Implementaciones existentes A continuacin se describen algunas de las implementaciones de MPI existentes en la actualidad: LAM, es una implementacin disponible en el centro de supercomputacin de Ohio, que ejecuta sobre estaciones de trabajo heterogneas Sun, DEC, SGI, IBM y HP. CHIMP-MPI, es una implementacin desarrollada en el Centro de Computacin Paralela de Edimburgo basada en CHIMP [6]. Esta implementacin ejecuta sobre estaciones de trabajo Sun, SGI, DEC, IBM y HP, y mquinas Meiko y Fujitsu AP-1000. MPICH, es una implementacin desarrollada de forma conjunta por el Laboratorio Argonne y la Universidad de Mississippi. Esta implementacin ejecuta sobre diferentes plataformas, redes de estaciones de trabajo Sun, SGI, RS6000, HP, DEC, Alpha, y multicomputadores como el IBM SP2, Meiko CS-2 y Ncube. UNIFY, disponible en la Universidad del Estado de Mississippi, es una implementacin que permite el uso de llamadas MPI y PVM de forma simultanea dentro del mismo programa. MPI-LITE, es una implementacin multithread de MPI, que ofrece un ncleo para la creacin, terminacin y planificacin de threads de usuario. Esta implementacin es la
_
43
Estado de la Tcnica
Marta Garca Nuevo
nica conocida por los autores que ofrece un cierto soporte para la ejecucin de programas multithread. Sin embargo, el modelo que ofrece MPI-LITE es muy rgido, puesto que los threads son de usuario, cada thread ejecuta una copia de un programa MPI, y adems, el nmero de threads en el programa es fijo y se especifica como un argumento de entrada a un programa MPI.
44
Marta Garca Nuevo
Herramientas de Visualizacin
Vamos ha hacer ahora una breve explicacin delas herramientas usadas para la visualizacin. stas son Matlab y VTK programando en Tcl. Para el procesamiento distribuido bajo Linux, utilizamos OpenMoxis y bajo Windows utilizamos ParaView.
3.1 Matlab [MWOR] [DMUU]

MATLAB (MATrix LABoratory) es un lenguaje de alto nivel que incorpora herramientas de clculo numrico y visualizacin. Es un programa de Mathworks para realizar todo tipo de clculos con vectores y matrices. Adems presenta la posibilidad de realizar grficos en dos y tres dimensiones.
Figura 3.1: Logo Matlab
45
Marta Garca Nuevo
Se pueden programar funciones con un cdigo propio muy parecido a otros lenguajes de programacin. Normalmente se expresan como scripts o macros que realizan las funciones deseadas sin necesidad de teclear comando a comando. Los archivos tienen extensin *.m. Incluye una herramienta de debug til para corregir errores de cdigo de los scripts creados. Matlab es un programa muy potente que realiza con gran precisin operaciones complejas. Se emplea en todo tipo de investigaciones donde se trabaja con funciones matemticas o matrices de puntos. Su entorno grfico es simple y su aprendizaje no requiere gran esfuerzo. Las nuevas versiones de Matlab, han sido adaptadas a la metodologa de diseo DSP, ya que permiten comenzar con la estructura del sistema en alto nivel e ir descendiendo a los detalles especficos del algoritmo o la implementacin. El desarrollo de sistemas basados en DSP se enmarca en un entorno de grandes cambios tecnolgicos y no todas las herramientas de diseo han sido capaces de seguir y adaptarse a esta situacin. Dentro del proceso de diseo, normalmente suelen convivir separadamente las fases de desarrollo de algoritmo y la de implementacin del prototipo. Antes de implementar el algoritmo sobre el prototipo real, este ha de ser simulado en otro entorno con la finalidad de analizar su comportamiento.
Figura 3.2: Ejemplo de pantalla de Matlab Los errores que puedan aparecer en las etapas de diseo del software o del hardware suponen volver a la etapa inicial de desarrollo del algoritmo y comenzar de nuevo. Para evitar este contratiempo muchos ingenieros estn aplicando una metodologa de diseo llamada Diseo Acelerado de DSP. Este nuevo enfoque integra el desarrollo del algoritmo con el diseo del sistema, utilizando para ello una simulacin del algoritmo en alto nivel y una rpida realizacin del prototipo, con la finalidad de obtener una pronta validacin del algoritmo y del diseo del mismo. Esta metodologa proporciona una
46
Marta Garca Nuevo
estructura jerrquica en la que el ingeniero de DSP puede simular cada paso con tanto detalle como sea necesario para conseguir el comportamiento necesario. Con Matlab se pueden desarrollar de una forma rpida nuevas ideas, incorporar funciones de toolboxes colecciones de funciones de MATLAB en torno a un rea especfica de trabajo, como el rea del procesado de seales, de imgenes, de redes neuronales, etc.), ejecutar una secuencia de simulaciones usando diferentes parmetros, y analizar el comportamiento resultante del sistema.
3.2 VTK [KITW]

VTK (Visualization Toolkit) son un conjunto de libreras destinadas a la visualizacin y el procesado de imgenes. Incluyen cdigo abierto y software orientado a objetos. Son muy amplias y complejas, pero an as, estn diseadas para ser sencillas de usar con cualquier lenguaje de programacin orientado a objetos, como son C++, Java, Tcl.
Figura 3.3: Logo VTK Son capaces de realizar operaciones sobre imgenes en dos dimensiones y de generar modelos en tres dimensiones con pocas lneas de cdigo. En apartados posteriores se detallarn las fases de creacin de objetos VTK, y su posible combinacin con Matlab. Debido a su gran potencia, se hacen necesarios amplios recursos de memoria en el PC para poder aprovechar en su totalidad sus funcionalidades.
Figura 3.4: Figura procesada con VTK.
47
Marta Garca Nuevo
Tenemos un ejemplo de uso de estas libreras, con los objetos que utiliza. El resultado que se obtiene es el siguiente:
Figura 3.5: Figura procesada con VTK. En este ejemplo, se lee un archivo con datos 3D, el cual se utiliza para inicializar un objeto de la clase vtkStructuredPoints, el cual modela una grilla regular de valores escalares
La asignacin se realiza por medio de un objeto vtkStructuredPointsReader, el cual recibe el nombre del archivo y fuerza la lectura con el mtodo update. Los datos 3D son renderizados por medio de transparencias, por lo que es necesario definir una funcin de transferencia que relacione el color y absorcin de cada celda en funcin del valor almacenado.
48
Marta Garca Nuevo
Un modelo para estas funciones es utilizar paletas definidas por medio de funciones lineales a trozos. La clase vtkPiecewiseFunction soporta este comportamiento, al poder ser definida por medio de segmentos. La clase vtkColorTransferFunction soporta este mismo comportamiento para paletas. En el ejemplo se utiliza un objeto de cada clase, para el color y la opacidad. Despus de ser definidos, son asignados como propiedades del volumen por medio de un objeto intermedio de la clase vtkVolumeProperty. Estas propiedades sern interpoladas trilinealmente durante el rendering. La geometra del volumen de datos y el mtodo de evaluacin de la misma se ponen en conjuncin con un objeto de la clase vtkVolumeMapper.La salida de este objeto, junto con las propiedades del volumen, son asignadas a un objeto vtkVolume, el cual es finalmente asignado al renderizador.
3.3 SDC [SDCM]

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 3.6: Logo SDC. Las SDC Morphology Toolbox trabajan con escala de grises y imgenes binarias (o seales), y es tipo de datos orientados. 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, 8bascula de bit-gris y 16-bascula de bit-gris, donde cada pxel es representado, respectivamente, por un lgico uint8, un uint8 y uint16 tipo de datos. Los operadores morfolgicos pueden ser escritos jerrquicamente desde dos operadores elementales: dilatacin y erosin. SDC tiene unas implementaciones muy eficientes para la dilatacin y erosin de herramientas para dilatacin y erosin. Sin embargo, para obtener ms eficiencia, varios operadores son tratados tambin por algoritmos rpidos especiales. Algunos de estos operadores son transformacin de la distancia, reconstruccin, etiquetando y apertura de reas.
49
Marta Garca Nuevo
Figura 3.7: Imagen binarizada y dilatada. Dilataciones y erosiones son parametrizadas por imgenes particulares (o seales), llamadas elementos estructurantes. La SDC Morphology Toolbox es soportada en 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
Imagen original
Figura 3.8
Imagen procesada Imagen procesada con VTK.
3.4 OPENMOXIS [NO3D]

OpenMosix es una especie de modificacin o conjunto de parches del kernel de Linux que permite una distribucin automtica y transparente de la carga de tareas a lo largo de las mquinas que forma el cluster. Y todo ello sin tener que modificar el cdigo del programa.
Figura 3.9: Logo OpenMosix.
50
Marta Garca Nuevo
Con OpenMosix se puede lanzar un proceso en una computadora y ver 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 significa 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 raz. OpenMosix se encargar de establecer la comunicacin entre estos 2 procesos. De entre las propiedades compartidas entre OpenMosix podemos destacar el mecanismo de migracin, en el que puede migrarse cualquiera proceso a cualquier nodo del cluster de forma completamente transparente al proceso migrado. 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, y las tareas que se estn ejecutando puedan migrar a cualquier otro nodo del cluster. As desde que se ejecuta una tarea hasta que sta muere, podr migrar de un nodo a otro, sin que el proceso sufra mayores cambios. Pros de OpenMosix No se requieren paquetes extra No son necesarias modificaciones en el cdigo Contras de OpenMosix Es dependiente del kernel (ncleo del sistema operativo) No migra todos los procesos siempre, tiene limitaciones de funcionamiento Problemas con memoria compartida entre procesos Tambin hay que sealar segn se comenta que OpenMosix consigue muy bien balancear la carga de programas que lanzan mltiples procesos mientras que no es demasiado efectivo si se trata de distribuir un proceso gordo. Otro aspecto que me ha llamado la atencin es que parece que la actual implementacin no se lleva demasiado bien con el Hyper-Threading de Intel por lo que se recomienda desactivarlo.
3.5 PARAVIEW [PARA]
Figura 3.10: Logo ParaView
51
Marta Garca Nuevo
ParaView es una aplicacin diseada por 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. Support distributed computation models to process large data sets. Crear una interface de usuario abierta, flexible e intuitiva. Desarrollar una arquitectura extensible basada en estndares abiertos.
Figura 3.11: Ejemplo imagen con tratada con SDC. ParaView funciona satisfactoriamente tanto en sistemas distribuidos en paralelo y compartiendo memoria como en sistemas de un nico procesador, se ha probado en Windows, Linux y los varios sitios de trabajo y cluster de Unix. En su base, ParaView utiliza VTK como procesador de datos y motor de la renderizacin y de la visualizacin, tiene un interfaz escrita usando una mezcla nica de Tcl/Tk y de C++. ParaView fue creado por Kitware junto con Jim Ahrens, el objetivo de este proyecto es desarrollar una herramienta paralela escalable que realice procesamiento distribuido de memoria. El proyecto incluye algoritmos el paralelo, infraestructura de entrada y salida, ayuda, y dispositivos de demostracin. Una caracterstica significativa es que todo el software desarrollado est hecho como cdigo abierto. Por lo tanto ParaView est disponible gratuitamente.
3.6 MPI [CARA]
Figura 3.12: Logo MPI.

52 GVA-ELAI-UPMPFC0077-2003
Marta Garca Nuevo
MPI es una estndar creado por un amplio comit 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 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 desarrollos, pero no en sus principios bsicos.
Figura 3.13: Logo MPI Reserch.
Existen actualmente diferentes implementaciones de MPI, algunas son comerciales y otras son gratis y portables a mltiples arquitecturas. En ste proyecto trabajaremos con 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 un una simple red local de ordenadores puede actuar como un ordenador multiprocesador.
53
Marta Garca Nuevo
54
Marta Garca Nuevo
Procesamiento
Procesamiento
La interpretacin de las imgenes de microscopa electrnica requiere de una gran calidad de stas, libres de ruido y seal espuria proveniente del sistema ptico del microscopio. Por lo tanto, resulta conveniente en la mayora de las veces procesarlas digitalmente y eliminar las seales no deseadas por medio del manejo de diferentes tcnicas.
4.1 Ficheros grficos [FPIC]

Cuando se desea almacenar un grfico o imagen digitalizada en un computador, esto se hace mediante el uso de un fichero grfico. Estos ficheros normalmente se dividen en dos partes, una denominada comnmente cabecera (header) donde se almacenan datos relativos al grfico que se almacena tales como ancho, alto, relacin entre pxel y unidad de medida, unidad de medida, tipo de imagen (color o blanco y negro), codificacin del color (componentes RGB, HSI, YCR, etc. o tabla de transformacin o "Lookup Table"), mtodo de compresin si lo hay, etc. A continuacin de la cabecera, vienen los datos del grfico o de la imagen digitalizada. stos datos pueden encontrarse comprimidos o no.
55
Procesamiento
Marta Garca Nuevo
As los ficheros que contienen grficos tienen por lo general la estructura que se muestra en la siguiente ilustracin: Cabecera Grfico o imagen digitalizada Algunos programas que acompaan a dispositivos que digitalizan imgenes (tarjetas de adquisicin de imgenes), no dan como salida ficheros grficos con un formato "estndar", sino que se limitan a dar la imagen digitalizada como una matriz de pxel con valores de niveles de gris o bien con alguna de las coordenadas de color (RGB, HSI, ...), a este tipo de fichero es a lo que vamos a denominar como ficheros raw o raster, es decir, ficheros donde la imagen se almacena digitalizada sin ningn tipo de cabecera, de forma que los datos relativos a tamao de la imagen en pxeles, tipo de imagen, etc. se deben conocer con anterioridad. 4.1.1 Formato grfico *.pic Este formato de ficheros grficos es en el que vienen los ficheros obtenidos del microscopio confocal. Este formato permite almacenar una imagen digitalizada por fichero, que puede se en tonos de gris o bien en color (RGB y HSI), y tambin una secuencia de imgenes en cada fichero. Se denomina slice a cada una de las imgenes que contiene el fichero, y siendo en este caso imgenes en tonos de gris. Los ficheros en este formato constan de una cabecera y a continuacin se encuentran cada uno de los slices que componen el fichero. La cabecera del fichero est compuesta por los datos que se dan en la siguiente tabla:
56
Marta Garca Nuevo
Procesamiento
Figura 4.1: Cabecera de los archivos *.PIC 4.1.2 Regiones de inters (ROI) Una regin de inters es una porcin de una imagen, que queremos filtrar o realizar alguna operacin sobre ella. Definimos una regin de inters creando una mscara binaria, que es una imagen binaria del mismo tamao que la imagen que queremos procesar. La mscara contiene unos en las zonas que queremos procesar y ceros en el resto.
4.1.2.1 Seleccin de la ROI
Figura 4.2: Seleccin de una ROI
El comando roipoly, permite elegir una regin de inters poligonal. Con este comando elegiremos los bordes del polgono pulsando con el ratn sobre la imagen original.
57
Procesamiento
Marta Garca Nuevo
BW = roipoly; Tambin podemos usar como mscara una imagen binaria, siendo sta del mismo tamao que la imagen original. Por ejemplo, si queremos filtrar una imagen de intensidad, podemos crearnos una mscara, filtrando slo los pxeles que superen una determinada intensidad. Podemos crear esta mscara con el siguiente comando: BW = (I > 0.5); Otra forma de crea una mscara adecuada es utilizando el comando roicolor, que define la regin de inters basndose en el rango de intensidad o color.
Figura 4.3: ROI de nuestra imagen 4.1.2.2 Filtrado de la ROI Podemos usar el comando roifilt2 para procesar la regin de inters. Al usar ste comando, tenemos que especificar una imagen de intensidad, una mscara binaria y el filtro que queremos aplicar. A estas operaciones la s llamamos filtros de mscara.
4.2 Descripcin de los comando usados en los cdigos

4.2.1 Apertura del .pic con Matlab Para lograr abrir los ficheros .pic en Matlab o en cualquier otro programa, lo ms importante, es saber leer e interpretar bien la cabecera del archivo. Tendremos que ir leyendo uno a uno los datos, con su correspondiente tamao y tipo, e iremos guardndolos como constantes.
58
Marta Garca Nuevo
Procesamiento
Los datos ledos y guardados, son: el nombre del fichero, tamao en pxeles de las dos coordenadas de las imgenes en 2D, el nmero de imgenes bidimensionales. Teniendo estos datos ya somos capaces de interpretar la informacin sobre las imgenes correctamente. Haremos un bucle que busque la imagen que queremos visualizar y nos indique si hay algn error en la eleccin del nmero de la slice.
Figura 4.4: Imagen original del microscopio confocal 4.2.2 Procesamiento de la imagen con Matlab Ya hemos logrado leer la cabecera de nuestro fichero .pic en Matlab, y gracias a esto abrir y visualizar en 2D la slice elegida. Ahora vamos a procesar la imagen, sometindola a diferentes tcnicas de filtrado. Los comandos que vamos a describir a continuacin, son los que han sido usados en el programa picfilter2.m Lo primero que hacemos es elegir nuestra regin de inters. Para ello aplicamos el comando roicolor. BW = ROICOLOR(A,LOW,HIGH) BW es una imagen binaria con ceros fuera de la regin de inters y unos dentro de sta.
59
Procesamiento
Marta Garca Nuevo
Llega el momento de buscar el tipo de filtro que mejor se adapta a nuestros objetivos. Para esto vemos las opciones que nos ofrece FSPECIAL, que crea filtros especiales en 2D. H = FSPECIAL(TYPE) Los tipos a elegir, son: 'AVERAGE', 'DISK', GAUSSIAN', 'LAPLACIAN', 'LOG, 'MOTION', 'PREWITT', 'SOBEL', UNSHARP'. En nuestro caso el que mejor funciona es el GAUSSIAN', que funciona como se muestra: H = FSPECIAL('gaussian',HSIZE,SIGMA) HSIZE: es un vector que especifica el nmero de filas y de columnas de H SIGMA: es la desviacin Por defecto los valores que toma Matlab son: HSIZE es [3 3] y SIGMA 0.5. Ahora aplicaremos el filtro a la regin de inters. B = IMFILTER(A,H) Filtra el array multidimensional A, con el filtro multidimensional H. Seguidamente realizaremos una erosin sobre la regin de inters ya filtrada, definiremos primeramente una matriz identidad de 3*3 que usaremos como elemento estructurante y luego lo aplicamos a la imagen. SE = eye (3) BW2 = ERODE(B,SE) Definimos ahora la deconvolucin que vamos a realizar sobre la imagen. Usaremos el comando DECONBLIND, que realiza una restauracin de la imagen usando el algoritmo de la blin deconvolucin. Tenemos que elegir un elemento estructurante, es nuestro caso nos viene bien una matriz de unos de dimensin 4. [J,PSF] = DECONVBLIND(I,INITPSF,NUMIT) INITPSF: es el elemento estructurante
60
Marta Garca Nuevo
Procesamiento
NUMIT: nmero de iteraciones Ahora realizamos el producto de la imagen obtenida con la ROI, para as obtener la imagen final. Picfilt = J .* BW2filt El .* es un operador de arrays, realiza el producto de las imgenes bit a bit. 4.2.3 Procesamiento de la imagen usando SDC El programa implementado usando SDC Morphology Toolbox para Matlab, da como resultado un mejor procesamiento y visualizacin de las imgenes. Nuestra imagen original, abierta con el comando MMSHOW, es:
Figura 4.5: Imagen original abierta con mmshow. Describimos seguidamente los comandos usados nuestro programa picarea.m. Muchos de estos comandos estn ya descritos en el apartado anterior, y el funcionamiento general es el mismo IM2BW lo usamos para convertir la imagen a binario por tcnicas de tresholding. Se producen imgenes binaras procedentes de imgenes indexed, intensity, o RGB. BW = IM2BW(I,LEVEL)
61
Procesamiento
Marta Garca Nuevo
Con MMAREAOPEN quitamos los puntos pequeos dispersos pos la imagen. Quita las zonas con rea menor que A de la imagen original. Y = MMAREAOPEN( F, A, BC )
F Escala de grises (uint8 or uint16) o imagen binaria (logical uint8). A - Integrador no negativo. BC Elemento estructurante Una vez limpia la imagen dejando slo pocos pxeles semilla, procedemos a hacer una dilatacin de la imagen buscando la regin de inters. Primeramente hacemos una dilatacin condicionada, esto es, hacemos crecer la imagen ya filtrada que contiene slo los pxeles semilla, tomando como gua de crecimiento la imagen original. Esto lo logramos utilizando el comando MMCDIL. Y = MMCDIL( F, G, B, N )
F Imagen binaria o en escala de grises G Imagen condicional binaria o en escala de grises B Elemento estructurante N Nmero de iteraciones Despus de la dilatacin condicionada, hacemos una dilatacin normal, para as terminar de definir nuestra regin de procesamiento. En este caso usamos el comando MMDIL. Y = MMDIL( F, B )
F - Imagen binaria o en escala de grises B - Elemento estructurante
62
Marta Garca Nuevo
Procesamiento
Figura 4.6: Dilatacin condicionada
Figura 4.7: Dilatacin normal
Finalmente realizando el producto entre la imagen de la ROI y la original, obtenemos nuestra imagen final.
Figura 4.8: Resultado usando SDC
4.2.4 Procesamiento de la imagen usando VTK Vamos a trabajar VTK. Con esta biblioteca open-source para visualizacin programando en Tcl, crearemos un programa que lea la cabecera de nuestro fichero .pic y abra y visualice la imagen en tres dimensiones.
63
Procesamiento
Marta Garca Nuevo
Para trabajar con esta librera iremos empleando clases, que se irn interrelacionando unas con otras, de forma que todas quedan enlazadas. Las clases empleadas son: vtkImageReader: La empleamos para leer la cabecera del fichero y guardar los datos de tamaos, colores... de forma que podamos recurrir luego a ellos de forma sencilla. vtkPieceWiseFunction: Es la funcin de transferencia que relaciona el color y la absorcin de cada celda. vtkColorTransferFunction: Tiene el mismo comportamiento que el anterior pero para paletas de colores. vtkVolumeProperty: Toma los objetos anteriormente definidos de color y opacidad como propiedades del volumen. Define como se van a visualizar los datos. vtkVolumeRayCastCompositeFunction: Define como renderizar nuestra imagen. vtkVolumeRayCastMapper: Aplica el compositeFunction a los datos que vamos a leer. vtkVolume: Junta lo obtenido en el volumeMapper y volumeProperty, podramos tambin usarlo para definir posiciones u orientaciones. vtkRenderer: Para finalmente renderizar la escena. Con todo esto obtenemos la visalizacin de la imagen en tres dimensiones.
Figura 4.9: Imagen 3D abierta con VTK
64
Marta Garca Nuevo
Procesamiento
4.2.5 Procesamiento usando VTK y Matlab Desde Matlab podemos ejecutar programas externos a ste, y hacerlo mediante hebras que no bloquean el funcionamiento del PC. Esto es lo que vamos a aplicar en ste caso. Realizaremos un programa que introduciendo el archivo .pic que queremos abrir y el nmero de la primera y ltima slice, llame al programa de VTK openpic3D.tcl y se visualice la imagen. Vamos a ejecutar el programa desde Matlab. Llamaremos a la funcin vtkopenpic.m, que nos pide los tres argumentos. Esta funcin guarda los datos de la primera y ltima slice que queremos abrir en dos archivos, y guarda tambin el nombre del fichero que queremos abrir en otro archivo. Para llamar al programa en tcl, introducimos la siguiente lnea de cdigo: !openpic3d.tcl & Estos tres archivos son luego ledos por openpic3D.tcl y usados como parmetros. El resultado de la visualizacin es el mismo que en el apartado anterior, pero pudiendo elegir las slices. 4.2.6 Observaciones En este momento estamos centrando la investigacin en aplicar los filtros ms convenientes y en seleccionar de forma apropiada la ROI. Por ello los resultados de los programas anteriormente descritos no son an los ms apropiados y estn pendientes de futuras mejoras.
4.3 Renderizacin
Es el proceso mediante el cual una estructura poligonal (tridimensional) digital obtiene una definicin mucho mayor. Esto se hace con juegos de luces, texturas y acentuado y mejorado de los polgonos, simulando ambientes y estructuras fsicas. Cuando se est trabajando en un programa profesional de diseo tridimensional por computadora, no se puede visualizar en tiempo real el resultado del diseo de un objeto o escena compleja ya que esto requiere una potencia de clculo extremadamente elevada, por lo que despus de disear el trabajo con una forma de visualizacin ms simple y tcnica, se realiza el proceso de renderizacin, tras el cual se puede apreciar el verdadero aspecto (aspecto final) de una imagen esttica o animacin.
65
Procesamiento
Marta Garca Nuevo
4.3.1 Mtodos de renderizacin Definimos rendering, en tratamiento de grficos por computadoras, como: Imagen tridimensional que incorpora la simulacin de efectos de iluminacin, tales como la sombra reflectiva. Un renderer es software y/o hardware que procesan datos de grficos, con objeto de visualizar, imprimir o exportar las figuras. Hay tres mtodos de renderizacin: OpenGL: librera de generacin de grficos tridimensionales, es compatible con casi todos los sistemas de computadoras. Este tipo de renderizacin es el ms rpido. Z-Buffer: Matlab dibuja rpidamente porque, los objetos son coloreados pxel a pxel, y solo se renderizan los pxeles visibles en la escena. Este mtodo puede consumir mucha memoria del sistema. Painters: Es el mtodo original de renderizacin en Matlab, es el ms rpido si la figura contiene solo objetos sencillos o pequeos. Los mtodos OpenGL y Z-buffer dibujan imgenes usando el mapa de bits (grficos raster). El mtodo Painters dibuja usando grficos de vectores, en general da resultados con mayor resolucin que los otros mtodos. Pero OpenGL y Z-buffer pueden trabajar en situaciones en las que Painters no produce buenos resultados o es incapaz de hacer nada. 4.3.2 Renderizacin en Matlab Por defecto Matlab selecciona automticamente los mejores mtodos de renderizacin basndose en las caractersticas de las figuras y en algunas ocasiones el mtodo de impresin o el formato del archivo usado. En general, MATLAB usa: - OpenGL para superficies complejas de los dibujos, usando interpolacin o juegos de luces. - Z-buffer cuando la visualizacin de la imagen no es en el color real. - Painter's para figuras de lneas, reas dibujos (grficos de barras, histogramas, etc...), y superficies sencillas. Usando los comandos de Matlab:
66
Marta Garca Nuevo
Procesamiento
Podemos seleccionar el tipo de renderizacin usando las propiedades de Renderer o el print command. Esto se hace de la siguiente manera, para Z-buffer. set(gcf, 'Renderer', 'zbuffer'); Salva el nuevo valor de Renderer con la figura. print zbuffer Afecta solo a la actual operacin. 4.3.3 Renderizacin con VTK Para representar y procesar una pila de imgenes en tres dimensiones las libreras de VTK son mucho mejores que Matlab. Usamos las libreras de VTK en los programas escritos en TCL/TK. Este modo de trabajar con estas libreras es muy cmodo. No es necesario construir , unir y compilar para tener un ejecutable como en otros lenguajes, por ejemplo en C++. Hemos escrito dos ficheros para representar las imgenes en tres dimensiones, segn el modo de representacin usaremos uno u otro: openpic3d.tcl Para el mtodo de renderizacin de volmenes. Este archivo es aplicable para visualizar archivos *.pic originales o filtrados, que estn definidos con 256 niveles de gris. Esta segunda opcin la usamos para renderizacin de superficies. Con este fichero podemos representar ficheros *.pic en blanco y negro, por ejemplo, los que se obtienen con los programas de Matlab picsuper.m y picsuperbw.m
picsuper3d.tcl
4.3.4 Razones para cambiar la renderizacin El mtodo de renderizacin usado para dibujar y exportar figuras, no es siempre el mismo que para visualizarlas. La razn ms importante para seleccionar la renderizacin despus de dibujar o exportar, es para hacer que la figura dibujada o exportada sea igual que la que se ve por pantalla. Otra razn para seleccionar la renderizacin, es para evitar que se exporte como bitmap en lugar de cmo formato vectorial. Cambia un formato bitmap a vectorial es un proceso largo. Si usamos uno de estos formatos y queremos estar seguros de que se guarda con formato vectorial, hay que elegir el mtodo de renderizacin Painters.
67
Procesamiento
Marta Garca Nuevo
4.3.5 Renderizacin de volmenes Est tcnica de renderizacin, consiste en dividir el objeto que nos interese representar en pequeos elementos de volumen llamados voxels, que miden cada uno una unidad de volumen. Cada voxel contiene valores sobre medidas u otras propiedades del volumen, su representacin tpica es como un cubo. En este tipo de representacin procesamos todos los voxels del objeto para lograr la visualizacin, lo que implica procesar mucha informacin, esto emplea muchos recursos del computador y hace que sea un proceso lento. Los resultados obtenidos son correctos y podremos realizar secciones para visualizar el interior del objeto. Todas las operaciones que realicemos necesitarn mucho tiempo de computacin, ya que se efectan sobre un nmero muy elevado de dados. Una de las ventajas de esta tcnica es que podemos visualizar el objeto sin necesidad de tener informacin sobre el tamao o la forma de nuestra regin de inters.
Figura 4.10: Volumen renderizado 4.3.6 Renderizacin de superficies En la renderizacin de superficies, los datos del volumen a representar deben ser procesados por distintos mtodos segn nos convenga, como isosurfacing, isocontouring, extracciones de los bordes... quedndonos solo con la informacin del exterior del objeto que nos interesa, es decir, como si el objeto estuviese hueco por dentro. El tiempo computacional para la visualizacin es elevado, incluso ms que en el caso anterior al ser el procesamiento ms complicado, sern necesarios potentes algoritmos y aplicar de forma exacta y correcta los filtros. La ventaja es que a la hora de la visualizacin, al rotar el objeto o realizarle otras operaciones es mucho ms rpido al tener slo la informacin del contorno, por esto no necesita mucha memoria para visualizarlo.
68
Marta Garca Nuevo
Procesamiento
Figura 4.11: Superficie renderizada 4.3.7 PICvisu toolbox Con los programas de esta toolbox, pretendemos tratar los ficheros *.pic. Los leeremos y posteriormente haremos su visializacin en dos o tres dimensiones segn corresponda. En estos, al hacer la visualizacin en tres dimensiones, haremos una renderizacin de volumen utilizando las libreras de VTK. 4.3.7.1 openpic.m El programa openpic.m nos permite visualizar las lonchas que elijamos de un fichero *.pic. Este programa lee el fichero entero y busca las lonchas que queremos representar. Esta representacin puede ser en dos dimensiones, si solo elegimos una loncha, en este caso realizar la visualizacin con Matlab. Si queremos representar ms de un loncha usaremos VTK, con estas libreras realizaremos la renderizacin de volumen y su visualizacin. Podemos elegir realizar o no la visualizacin, independientemente de esto, el resultado ser guardado en una variable de Matlab, sobre la que podemos operar comodamente. Para ejecutar este programa en Matlab, en la lnea de comandos pondremos: >> figure = openpic('nuevo1.pic',20,40,1); De esta manera, tomaremos el fichero indicado, abriremos desde la loncha 20, hasta la 40 y, por haber puesto el ltimo parmetro distinto de cero, se realizar la visualizacin de estas 20 lonchas en 3D. En Matlab quedar guardada una variable llamada figure, con los datos de stas lonchas visualizadas.
69
Procesamiento
Marta Garca Nuevo
Ahora veremos el cdigo fuente de esta funcin de Matlab. Los comentarios adjuntos facilitarn la comprensin del cdigo, aunque no son muy extensos y puede ser necesario recurrir a la funcin help de Matlab para comprender algunos comandos. La primera parte de la funcin vtkopenpic.m es para leer la informacin importante de la cabecera del fichero, y para decidir la forma de actuar, segn los argumentos introducidos. function Img3D = openpic(acFilename, nLimInf, nLimSup, Visu); fid = fopen(acFilename,'rt','l'); nPictureSize = fread(fid,[1,2],'int16'); nX = nPictureSize(1,1); nY = nPictureSize(1,2); nNumberOfImages = fread(fid,1,'int16'); xRampAndNotes = fread(fid,6,'int16'); acNametemp = fread(fid,[1,32],'uchar'); acName = char(acNametemp); xTemp = fread(fid,26,'int8'); nSliceNumber = nLimSup - nLimInf; nNum1 = nLimInf; nNum2 = nLimSup; warning('off', 'all'); La siguiente parte de la funcin es para realizar la visualizacin en dos o tres dimensiones, segn proceda. Si el nmero de la loncha inferior y de la superior es el mismo, estaremos en el primer caso, procesaremos una sola loncha y la visualizaremos en dos dimensiones. Lo primero que hacemos es buscar la loncha indicada, si es la primera, leemos los sus datos y realizamos sobre ellos el procesamiento ya descrito en el apartado anterior. Si en visu no hemos introducido cero realizamos la visualizacin del resultado con Matlab. %For only one slice, it is visualice with Matlab if nSliceNumber == 0 nNum = nLimInf; if nNum == 1 pic = fread(fid, [nX, nY], 'uint8'); if Visu ~= 0; imshow(uint8(pic)); Img3D(:,:)=(uint8(pic)); else Img3D(:,:)=(uint8(pic)); display('You choose not to visualice'); end
70
Marta Garca Nuevo
Procesamiento
Si la loncha elegida no es la primera tendremos que leer los datos anteriores hasta llegar a los que nos interesan. Sobre estos datos realizamos el mismo procesamiento anterior y la visualizacin si procede. Detectaremos aqu posibles errores en los datos introducidos, mostrando un mensaje de error si es necesario. elseif (1 < nNum) & (nNum <= nNumberOfImages) for i = 1:nNum pic = fread(fid,[nX, nY],'uint8'); end if Visu ~= 0; imshow(uint8(pic)); Img3D(:,:,1)=(uint8(pic)); else Img3D(:,:,1)=(uint8(pic)); display('You choose not to visualice'); end else display ('Wrong image number, it must be betwen 0 and the last slice'); end fclose(fid); Cuando lo que queremos es visualizar una imagen en tres dimensiones, es decir, varias lonchas, recurrimos a las libreras VTK con las que el proceso es ms rpido y sencillo. El programa busca las lonchas elegidas, sobre stas realiza el procesamiento y la visualizacin si procede. Guardaremos en archivos de texto la informacin de los argumentos introducidos, para que puedan ser ledos por el programa openpic3D.tcl, que es el fichero de VTK encargado de realizar la visualizacin. %For more than one slice, it is visualice with VTK else if nLimInf < nLimSup if (nNum1 > 0) & (nNum2 <= nNumberOfImages) for i = 1:(nNum1-1) fread(fid,[nX, nY],'uint8'); end for i = 1: (nSliceNumber+1) pic=fread(fid,[nX, nY],'uint8'); Img3D(:,:,i)=(uint8(pic)); end if Visu == 0; display('you choose not to visualice'); fclose(fid); else fclose(fid); %Create new file for read the number of the first slice
71
Procesamiento
Marta Garca Nuevo
fid = fopen('VTKFirstSlice.txt','wt'); fwrite(fid, sprintf('%d',(nNum1 -1)),'char'); fclose(fid); %Create new file for read the number of the last slice fid = fopen('VTKLastSlice.txt','wt'); fwrite(fid, sprintf('%d',(nNum2 -1)),'char'); fclose(fid); %Create new file for read the name of the file *.PIC to open fid = fopen('VTKFilename.txt','wt'); fwrite(fid, sprintf('%c',acFilename),'char'); fclose(fid); %Calls the tcl program, to open the image .pic !openpic3d.tcl & end else display('Wrong image numbers, nLimInf must be bigger than 0, and nLimSup must be smaller than the last slice'); end else display('Wrong image numbers, nLimInf must be smaller than nLimSup'); end end Vemos ahora un ejemplo de una imagen obtenida con este programa.
Figura 4.12: Imagen 3D obtenida con openpic.m

72 GVA-ELAI-UPMPFC0077-2003
Marta Garca Nuevo
Procesamiento
4.3.7.2 vtk3D.m El programa vtk3D.m nos permite visualizar una variable de Matlab en 3D. Esta variable ser una pila de imgenes en dos dimensiones, por ejemplo, las variables generadas en el programa anterior, openpic.m. Para poder visualizar estas variables de Matlab, como lo hacamos con los ficheros *.pic, tendremos que saber cual es el tamao de cada loncha en dos dimensiones y el nmero de lonchas que tenemos. Esto es lo que hacemos en la primera parte del programa, que seguidamente detallamos: function[] = vtk3D(Img3D); nSize=[1 1 1]; nSize=size(Img3D); nX=nSize(1,1); nY=nSize(1,2); warning('off', 'all'); %if we have more than one slice, Img3D is 3D if size(nSize)==[1 3] nNumberOfImages=nSize(1,3) %if we have only one slice, Img3D is 2D else display('we have not a 3D image'); end
Guardaremos estos datos en un fichero auxiliar que tendr el mismo formato que los *.pic habituales, as podremos usar para abrirlo los mismos ficheros que anteriormente. %for save the size and datafield in the correct format acFilename=('/temp/newfile.pic'); fid1 = fopen(acFilename,'w','l'); fwrite(fid1,nX,'int16'); fwrite(fid1,nY,'int16'); fwrite(fid1,nNumberOfImages,'int16'); fread(fid1, 70, 'uint8'); fwrite(fid1, Img3D, 'uint8'); fclose(fid1); Una vez que tenemos escrita la cabecera del fichero auxiliar, y los datos de las imgenes, guardemos los datos que VTK necesita para hacer la visualizacin en ficheros de texto. Hecho esto llamaremos a openpic3D.tcl para realizar la visualizacin. Nos damos cuenta que estamos actuando de idntica forma que en anteriores ocasiones.
73
Procesamiento
Marta Garca Nuevo
%Create new file for read the number of the first slice fid = fopen('VTKFirstSlice.txt','wt'); fwrite(fid, sprintf('%d',1),'char'); fclose(fid); %Create new file for read the number of the last slice fid = fopen('VTKLastSlice.txt','wt'); fwrite(fid, sprintf('%d',(nNumberOfImages -1)),'char'); fclose(fid); %Create new file for read the name of the file *.PIC to open fid = fopen('VTKFilename.txt','wt'); fwrite(fid, sprintf('%c',acFilename),'char'); fclose(fid); %Calls the tcl program, to open the image .pic !openpic3d.tcl & 1.7.3 savepic.m Ahora que podemos crear variables de Matlab con un pila de imgenes en dos dimensiones, nos interesa poder guardarlo como archivos con formato *.pic. As crearemos nuevos archivos de imagen con las lonchas que que nos den la informacin ms adecuada a nuestras necesidades. Para ello usamos este programa. Para ejecutarlo tendremos que indicar la variable de Matlab que queremos guardar y el nombre con el que queremos hacerlo, de sta forma: >> savepic(variable,nueva.pic); El cdigo del programa necesario para hacer esto es el siguiente: function savePIC (Img3D, achFile) nSize=[1 1 1]; nSize=size(Img3D); nX=nSize(1,1); nY=nSize(1,2); %if we have more than one slice, Img3D is 3D if size(nSize)==[1 3] nNumberOfImages=nSize(1,3); %if we have only one slice, Img3D is 2D else nNumberOfImages=1; end
74
Marta Garca Nuevo
Procesamiento
%for save the size and datafield in the correct format fid = fopen(achFile,'w','l'); fwrite(fid,nX,'int16'); fwrite(fid,nY,'int16'); fwrite(fid,nNumberOfImages,'int16'); fread(fid, 70, 'uint8'); fwrite(fid, Img3D, 'uint8'); fclose(fid); Lo primero que hemos hecho es ver el tamao de las imgenes y el nmero de stas para crear la cabecera del fichero con el formato establecido para los ficheros *.pic, y tras la cabecera copiaremos la variable de Matlab, que contiene una matriz con la informacin de la imagen. Mostramos un ejemplo en el que usamos los tres programas anteriores para entender as mejor su aplicacin: Tomamos de nuestro fichero de pruebas nuevo1.pic, las diez lonchas centrales que son las ms ntidas, lo hacemos usando openpic.m, no lo visualizamos, tan solo obtenemos una variable que llamamos imagen.
Figura 4.13: Workspace de Matlab Ahora con savepic.m guardamos la variable como archivo *.pic, con el nombre imagen.pic.
75
Procesamiento
Marta Garca Nuevo
Figura 4.14: Current Directory de Matlab Visualizamos este archivo entero y vemos que solo esta formado por las diez lonchas centrales del nuevo1.pic.
Para realizar este proceso los comandos exactos que hay que teclear en la ventana de Matlab, son los siguientes:
76
Marta Garca Nuevo
Procesamiento
Figura 4.16: Pantalla al ejecutar el programa openpic.m Este proceso es meramente demostrativo, para ver como enlazar los distintos programas y su aplicacin. Para realizar esta visualizacin, habra sido suficiente con poner algo distinto de cero en el ltimo parmetro de la primera llamado a openpic.m, obteniendo el mismo resultado, pero sin tener guardado el archivo imagen.pic. 1.7.4 openpic3D.tcl Los programas opensup.m y opensupbw.m los usamos para procesar y seleccionar los datos que luego necesita openpic3D.tcl para realizar la visualizacin. Este programa est escrito en tcl, que es un leguaje de programacin de fcil aprendizaje y manejo. Utiliza las libreras de VTK, ya descritas anteriormente. Daremos ahora una breve explicacin del cdigo fuente del programa openpic3D.tcl, las lineas precedidas de # son comentarios y no forman parte del cdigo fuente. #Estas dos primeras lineas son estandar de los ficheros *.tcl. #Se encargan de llamar a las librerias de VTK y
77
Procesamiento
Marta Garca Nuevo
#al programa para ejecutar el cdigo fuente escrito debajo. catch {load vtktcl} source vtkInt.tcl #Ahora leemos los ficheros de texto con la informacin obtenida de Matlab #y lo guardamos como variables de TCL set fd1 [open "VTKFirstSlice.txt" "r"] set fd2 [read $fd1] set fd3 [open "VTKLastSlice.txt" "r"] set fd4 [read $fd3] set file1 [open "VTKFilename.txt" "r"] set file2 [read $file1] set head1 [open $file2] set head2 [read $head1 6] binary scan $head2 s1s1s1 nx ny nz set nx [expr $nx -1] set ny [expr $ny -1] set nz [expr $nz -1] # Ahora tenemos el reader para los datos # seleccionamos el nombre del fichero, las dimensiones de la pila de imgenes # y el vtkImageReader reader reader SetFileName "$file2" 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 1.0 reader SetHeaderSize 76 # Ahora tenemos un filtro para quitar las partes oscuras del fondo de las # imgenes vtkPiecewiseFunction opacityTransferFunction opacityTransferFunction AddPoint 60 1.0 opacityTransferFunction AddPoint 255 1.0 opacityTransferFunction ClampingOff #Con la transfer function cambiamos los colores de escala de grises a RGB vtkColorTransferFunction colorTransferFunction colorTransferFunction AddRGBPoint 0.0 0.0 0.0 0.0 colorTransferFunction AddRGBPoint 255.0 1.0 1.0 1.0
78
Marta Garca Nuevo
Procesamiento
# Modificamos las propiedades definiendo el VolumeProperty vtkVolumeProperty volumeProperty volumeProperty SetColor colorTransferFunction volumeProperty SetScalarOpacity opacityTransferFunction volumeProperty SetInterpolationTypeToLinear # En este paso definimos el modo de lectura, usamos el volume rederer # Cambiamos las lonchas a un volumen en 3D vtkVolumeRayCastCompositeFunction compositeFunction vtkVolumeRayCastMapper volumeMapper volumeMapper SetVolumeRayCastFunction compositeFunction volumeMapper SetInput [ reader GetOutput] # La ltima parte crea la ventana y enlaces necesarios a las propiedades vtkVolume volume volume SetMapper volumeMapper volume SetProperty volumeProperty vtkRenderer ren1 ren1 AddVolume volume vtkRenderWindow renwin renwin AddRenderer ren1 vtkRenderWindowInteractor iren iren SetRenderWindow renwin ren1 SetBackground 0 0 0 renwin SetSize 500 500 iren Initialize iren AddObserver SetExitMethod { exit } wm withdraw . wait forever El resultado obtenido aparece en la pantalla tras el tiempo necesario para el procesamiento. En la siguiente figura mostramos uno de los resultados que es posible obtener. La imagen de la ventana es un volumen que podemos mover y rotar pulsando con el botn izquierdo del ratn sobre la imagen. Podemos tambin hacer un zoom aumentando o reduciendo la figura pulsando con botn derecho del ratn. Pero estas operaciones de giro o zoom requieren gran capacidad computacional, si no tenemos un computador potente puede resultar algo lento.
79
Procesamiento
Marta Garca Nuevo
Ejemplo de openpic3d.tcl
Figura 4.17: Resultado de openpic3D.tcl 4.3.8 PICsuper toolbox Hemos creado una toolbox en Matlab para realizar la renderizacin de superficie. Lo que hacen los programas que contiene, es procesar las imgenes atendiendo a extraer los bordes o a seleccionar la regin de inters, para despus realizar su visualizacin utilizando VTK. 4.3.8.1 Picsuper / picsuperbw La funcin picsuper.m se encarga de procesar el archivo *.pic entero, selecciona el rea de inters de cada loncha en 2D, y extrae los bordes, devuelve la pila de imgenes el blanco y negro. La funcin de Matlab picsuperbw.m realiza un procesamiento parecido, extrae las regiones de inters y devuelve las imgenes en blanco y negro. La seleccin adecuada de la ROI, la vemos a continuacin el los cdigos de los programas. Para ejecutar estos programas, en la lnea de comandos tendremos que teclear algo parecido a esto: >> bordes = picsuper('nuevo1.pic', 'savename.pic');
80
Marta Garca Nuevo
Procesamiento
Haciendo esto, procesaremos el archivo nuevo1.pic, y guardaremos el resultado en savename.pic, se guardar una pila de imgenes en blanco y negro con la informacin de los bordes y formato *.pic. Si la imagen no la tenemos en el directorio actual de Matlab, tendremos que especificar la ruta de directorios donde encontrarlo. Pasa igual para especificar dnde queremos guardar el resultado, si no especificamos ruta de directorios se guardar el directorio actual de Matlab. Ahora veremos el cdigo fuente de esta funcin de Matlab. Los comentarios adjuntos facilitarn la comprensin del cdigo, aunque no son muy extensos y puede ser necesario recurrir a la funcin help de Matlab para comprender algunos comandos. La primera parte de la funcin picsuper.m es para leer la informacin importante de la cabecera del fichero, y para copiar la cabecera el fichero destino, ya que el nuevo archivo tendr el mismo tamao y nmero de imgenes que el original. function[bor] = picsuper(acFilename, acSavename); fid = fopen(acFilename,'rt','l'); nPictureSize = fread(fid,[1,2],'int16'); nX = nPictureSize(1,1); nY = nPictureSize(1,2); nNumberOfImages = fread(fid,1,'int16'); fclose(fid); fid = fopen(acFilename,'rt'); cabezera = fread(fid, 76, 'uint8'); fid2 = fopen(acSavename,'wt'); identifierfwrite(fid2, cabezera, 'uchar'); %original file identifier %width in pixels %height in pixels %number of slices %original file identifier %read the whole header %destination file %write header to destination .
La siguiente parte del fichero es igual en este grupo de programas. En esta parte elegimos la regin de inters como ya explicamos en el apartado correspondiente, extraemos los bordes de la ROI y lo guardamos en el archivo especificado. for i = 1:nNumberOfImages pic = fread(fid,[nX,nY],'uint8'); bw = im2bw(uint8(pic), 0.25); %convert to black & white im = mmareaopen(uint8(bw), 250); bw1 = im2bw(uint8(pic), 0.2); im1 = mmareaopen(uint8(bw1), 550); b1 = mmcdil(im, im1, mmsecross(10), 10); %dilation with conditions x = mmdil(b1, mmsedisk(2)); bor(:,:,i) = edge(x, 'canny'); %find the borders end fclose(fid); %close the original file fwrite(fid2, bor, 'uchar'); %write the processesed file fclose(fid2); %close the destination file La diferencia con picsuperbw.m , es que en este no extraemos los bordes, pero usamos las imgenes en blanco y negro de la ROI.
81
Procesamiento
Marta Garca Nuevo
Seguidamente mostramos un ejemplo de cmo se visualizan las imgenes procedentes de picsuper.m y picsuperbw.m, seleccionando para la visualizacin una sola loncha del archivo obtenido.
Figura 4.18: Resultado de picsuper.m
Figura 4.18: Resultado de picsuperbw.m
82
Marta Garca Nuevo
Procesamiento
1.7.2
Opensup / opensupbw
Los programas opensup.m y opensupbw.m realizan un procesamiento idntico al que realizan picsuper.m y picsuperbw.m. La gran ventaja de stos respecto a los anteriores, es que ahora no es necesario procesar el archivo completo, sino que podemos elegir una o ms lonchas sobre las que realizar el procesamiento. En este caso no se guardan directamente los resultados el un fichero, sino que se salva como una variable de Matlab, que contiene una matriz con los datos de las imgenes procesadas. Tendremos despus la opcin de guardar estos datos con el formato *.pic, utilizando el programa savePIC.m, del que describiremos su funcionamiento ms adelante. Para ejecutar estos programas, en la lnea de comandos tendremos que teclear algo parecido a esto: >> bordes = opensup('nuevo1.pic', limInf, limSup, visu); Haciendo esta operacin, tomamos el archivo nuevo1.pic, y seleccionamos en ste la informacin desde la loncha indicada por limInf, hasta la que indica limSup, si ambas coincidiesen se procesara una nica loncha y haciendo la visualizacin lo obtendramos en 2D. sta imagen, o pila de imgenes ser guardada como una variable de Matlab, una matriz con la informacin de las rodajas procesadas, al no tener cabecera no es de formato *.pic, habr que aadirla si deseamos guardarlo as. En la primera parte de este programa leemos de la cabecera del fichero indicado. Tomamos los datos necesarios para la representacin, stos datos son el nmero de imgenes y su tamao. En esta parte definimos tambin el nmero de imgenes que vamos a visualizar, con los datos que tenemos de la primera y ltima lonchas de inters. Nos quedaremos apuntando al primer dato de la primera imagen. function Sup = openSup(acFilename, nLimInf, nLimSup, Visu); fid = fopen(acFilename,'rt','l'); nPictureSize = fread(fid,[1,2],'int16'); %opens file indicated by "acFilename" %reads the first two double-bytes %with the size of each picture
nX = nPictureSize(1,1); nY = nPictureSize(1,2); nNumberOfImages = fread(fid,1,'int16'); xRampAndNotes = fread(fid,6,'int16'); acNametemp = fread(fid,[1,32],'uchar'); acName = char(acNametemp); xTemp = fread(fid,26,'int8'); nSliceNumber = nLimSup - nLimInf; nNum1 = nLimInf; nNum2 = nLimSup; En este caso, como en otros ya descritos, dividiremos el resto del programa en dos partes, la primera de ella ser para cuando tengamos que visualizar una sola loncha en dos
83
Procesamiento
Marta Garca Nuevo
dimensiones, en la otra parte programaremos como hacer el procesamiento de varias lonchas y su visualizacin el tres dimensiones. if nSliceNumber == 0 nNum = nLimInf; if nNum == 1 pic = fread(fid, [nX, nY], 'uint8'); bw = im2bw(uint8(pic), 0.25); im = mmareaopen(uint8(bw), 250); bw1 = im2bw(uint8(pic), 0.2); im1 = mmareaopen(uint8(bw1), 550); b1 = mmcdil(im, im1, mmsecross(5), 5); b2 = mmareaclose(b1, 50); x = mmdil(b2, mmsecross); pic(:,:,nNum) = edge(x, 'canny'); Sup(:,:)=(uint8(pic)); if Visu ~= 0; imshow(pic); else display('You choose not to visualice'); end elseif (1 < nNum) & (nNum <= nNumberOfImages) for i = 1:(nNum-1) aux = fread(fid,[nX, nY],'uint8'); end pic = fread(fid,[nX, nY],'uint8'); bw = im2bw(uint8(pic), 0.25); im = mmareaopen(uint8(bw), 250); bw1 = im2bw(uint8(pic), 0.2); im1 = mmareaopen(uint8(bw1), 550); b1 = mmcdil(im, im1, mmsecross(5), 5); b2 = mmareaclose(b1, 50); x = mmdil(b2, mmsecross); pic(:,:,1) = edge(x, 'canny'); Sup(:,:)=(uint8(pic)); if Visu ~= 0; imshow(pic); else display('You choose not to visualice'); end else display ('Wrong image number, it must be betwen 0 and the last slice'); end fclose(fid); Realizamos ahora la visualizacin en tres dimensiones.
84
Marta Garca Nuevo
Procesamiento
%For more than one slice, it is visualice with VTK else if nLimInf < nLimSup if (nNum1 > 0) & (nNum2 <= nNumberOfImages) for i = 1:(nNum1-1) fread(fid,[nX, nY],'uint8'); end for i = 1: (nSliceNumber+1) pic=fread(fid,[nX, nY],'uint8'); bw = im2bw(uint8(pic), 0.25); im = mmareaopen(uint8(bw), 250); bw1 = im2bw(uint8(pic), 0.2); im1 = mmareaopen(uint8(bw1), 550); b1 = mmcdil(im, im1, mmsecross(5), 5); b2 = mmareaclose(b1, 50); x = mmdil(b2, mmsecross); pic(:,:,i) = edge(x, 'canny'); Sup=(uint8(pic)); end if Visu == 0; display('you choose not to visualice'); fclose(fid); else fclose(fid); Nos encontramos ahora con un problema, para realizar la visualizacin con VTK, utilizaremos el programa picsuper3D.tcl descrito en el siguiente punto. Este programa logra visualizar ficheros *.pic, es decir ficheros con cabecera y datos. El problema es que nosotros hasta ahora tenemos guardados nuestros resultados como una variable de Matlab, que contiene slo datos, tendremos que guardarlos ahora en un fichero dnde escribiremos tambin la cabecera adecuada. Tras sta operacin guardaremos los datos que ms tarde necesitar el programa de VTK, como ya hemos hecho en otras ocasiones. nSize=[1 1 1]; nSize=size(Sup); nX=nSize(1,1); nY=nSize(1,2); nNumberOfImages=nSize(1,3); acFilename1=('newfile.pic'); fid3 = fopen(acFilename1,'w','l'); fwrite(fid3,nX,'int16'); fwrite(fid3,nY,'int16'); fwrite(fid3,nNumberOfImages,'int16'); fread(fid3, 70, 'uint8'); fwrite(fid3, Sup, 'uint8'); fclose(fid3);
85
Procesamiento
Marta Garca Nuevo
%Creamos un nuevo fichero para leer el numero %Create new file for read the number of the first slice fid = fopen('VTKFirstSlice.txt','wt'); fwrite(fid, sprintf('%d',1),'char'); fclose(fid); %Create new file for read the number of the last slice fid = fopen('VTKLastSlice.txt','wt'); fwrite(fid, sprintf('%d',(nNumberOfImages -1)),'char'); fclose(fid); %Create new file for read the name of the file *.PIC to open fid = fopen('VTKFilename.txt','wt'); fwrite(fid, sprintf('%c',acFilename1),'char'); fclose(fid); %Calls the tcl program, to open the image .pic !picsuper3D.tcl & end else display('Wrong image numbers, nLimInf must be bigger than 0, and nLimSup must be smaller than the last slice'); end else display('Wrong image numbers, nLimInf must be smaller than nLimSup'); end end Vemos ahora un ejemplo de una imagen obtenida con este programa.
Figura 4.19: Resultado de opensup.m
86
Marta Garca Nuevo
Procesamiento
El programa opensupbw.m, funciona con idntica estructura que el descrito anteriormente opensup.m. La nica diferencia es a la hora del procesamiento, en el caso anterior nos quedbamos slo con los bordes y ahora con la superficie completa. Vemos un ejemplo.
Figura 4.20: Resultado de opensupbw.m

1.7.2
Picsuper3d.tcl
Este programa de VTK lo usamos para hacer renderizacin de superficies. Con este programa podemos visualizar ficheros *.pic en blanco y negro Los programas opensup.m y opensupbw.m los usamos para procesar y seleccionar los datos que luego necesita openpic3D.tcl para realizar la visualizacin. Toda la primera parte del programa es igual que la del programa openpic3D.tcl, que est explicada anteriormente. Solo expondremos ahora las partes diferentes del programa. reader SetHeaderSize 76 #Esta parte es un filtro para mejorar la imagen vtkImageGaussianSmooth smooth smooth SetInput [reader GetOutput] smooth SetDimensionality 3 smooth SetStandardDeviations 0.5 0.5 0.5 smooth SetRadiusFactors 1.0 1.0 1.0
87
Procesamiento
Marta Garca Nuevo
#Ahora estamos quitando las partes oscuras del fondo de la imagen vtkPiecewiseFunction opacityTransferFunction opacityTransferFunction AddPoint 0.5 1.0 opacityTransferFunction AddPoint 1 1.0 opacityTransferFunction ClampingOff #Con esta transfer function cambiamos los colores de B/N a RGB vtkColorTransferFunction colorTransferFunction colorTransferFunction AddRGBPoint 0.0 0.0 0.0 0.0 colorTransferFunction AddRGBPoint 1.0 1.0 1.0 1.0 #Ahora aplicamos las propiedades antes definidas al volumen vtkVolumeProperty volumeProperty volumeProperty SetColor colorTransferFunction volumeProperty SetScalarOpacity opacityTransferFunction volumeProperty SetInterpolationTypeToLinear volumeProperty ShadeOn #En este mtodo definimos el mtodo de rederizacin, # usamos la renderizacin de superficie #esto cambia las lonchas a un volumen en tres dimensiones vtkVolumeRayCastIsosurfaceFunction isosurfaceFunction isosurfaceFunction SetIsoValue 0.3 vtkVolumeRayCastMapper volumeMapper volumeMapper SetInput [ reader GetOutput] volumeMapper SetVolumeRayCastFunction isosurfaceFunction volumeMapper SetSampleDistance 0.5 #Cambiamos la iluminacin del volumen vtkLight light light SetColor 0.9 0.9 0.9 light SetFocalPoint 250 250 50 light SetPosition 500 500 70 light SetLightTypeToHeadlight light SetIntensity 7 # La ltima parte crea la ventana y enlaces necesarios a las propiedades vtkVolume volume volume SetMapper volumeMapper volume SetProperty volumeProperty
88
Marta Garca Nuevo
Procesamiento
vtkRenderer ren1 ren1 AddVolume volume ren1 AddLight light vtkRenderWindow renwin renwin AddRenderer ren1 vtkRenderWindowInteractor iren iren SetRenderWindow renwin ren1 SetBackground 0.2 0.2 0.2 renwin SetSize 500 500 iren Initialize iren AddObserver SetExitMethod { exit } wm withdraw . vwait forever Al ejecutar este programa se abrir una ventana con el resultado obtenido, mostramos un ejemplo de este resultado en la siguiente figura. La imagen de la ventana es un volumen, que podemos mover y rotar pulsando con el botn izquierdo del ratn sobre la imagen. Podemos tambin hacer un zoom aumentando o reduciendo la figura pulsando con botn derecho del ratn. Pero estas operaciones de giro o zoom requieren gran capacidad computacional, si no tenemos un computador potente puede resultar algo lento.
Figura 4.21: Resultado de opensupbw.m
89
Procesamiento
Marta Garca Nuevo
90
Marta Garca Nuevo
Aproximacin Poligonal
5.1 Niveles de detalle [MKRU] [CHXU]

Los requerimientos de computacin y almacenamiento para las imgenes con las que trabajamos exceden por mucho la capacidad del hardware. Estas imgenes tienen una estructura compleja y su despliegue requiere un nmero grande de polgonos no obstante cuando se considera solo la porcin de la escena que es visible para el marco dado. Para solucionar estos problemas computacionales es posible el uso de versiones mas simples de la geometra. Estas simplificaciones son llamadas Niveles de Detalle (LODs). La meta de la simplificacin poligonal, cuando se usa para la generacin de los niveles de detalle, es remover primitivas de una malla original para producir modelos mas simples los cuales retienen la caracterstica visual importante del objeto original. Idealmente, el resultado deberan de ser una serie completa de simplificaciones, la cual puede ser usada en varias condiciones. La idea, para mantener una tasa de marco constante, es encontrar un buen balance entre lo rico de los modelos y el tiempo que toma para desplegarlos.
91
Marta Garca Nuevo
Se necesita una serie de simplificaciones a ser seleccionadas al tiempo de despliegue. Si esta lista es continua, es decir dos LODs sucesivos difieren por solamente uno o dos polgonos, es llamada geomrfica . Los algoritmos producen estructuras de datos de las cuales cualquier simplificacin puede ser recuperada. Tales estructuras de datos habilitan un despliegue suave de LODs y el cambio de uno al siguiente no es notable.
Figura 5.1: Una sucesin de LODs La prctica mas comn es producir un nmero limitado de LODs. Ya que las diferencias de LODs son entonces mas grandes, la conmutacin de uno a otro es comnmente notable por el observador (esto es conocido como el efecto popping). La principal dificultad en este caso es calcular cuales niveles de simplificacion pudieran ser necesitados en la escena. La simplificacin debe de conducirse de tal forma que la forma general y las caractersticas que hacen que el objeto sea identificable fcilmente sean preservadas. Entonces, los algoritmos tienen que mirar por algunas formas distintas del objeto:
El rea planar puede ser identificada inspeccionando las normales de los polgonos adyacentes. Estos polgonos pueden entonces ser combinados para formar unos mas grandes. Este es el tipo mas comn de simplificacion ya que es relativamente fcil de calcular (no obstante la relacin de adyacencia debe ser conocida). Los bordes pronunciados pueden aparecer y deben ser preservados. Ellos se pueden encontrar al comparar el ngulo entre las normales de las caras adyacentes. Ellos pueden entonces ser simplificados al combinar bordes conectados las cuales son casi colineales. Los bordes apuntados (tales como la punta de una pirmide) deben ser preservados ya que tienen mucha oportunidad de aparecer en la silueta del objeto. Ellos pueden ser detectados midiendo la curvatura local alrededor de un vrtice. Ellos pueden ser simplificados empujando los vrtices prximos hacia la punta del pico.
La mayora de los algoritmos buscan bordes pronunciados, bordes colineales conectados y caras adyacentes coplanares. Pero cuando se prueba, por ejemplo por caras coplanares, los algoritmos tienen un valor de umbral para el ngulo entre las normales, arriba del cual las caras no son consideradas planares. Mientras mas alto sea este valor, ms caras sern consideradas
92
Marta Garca Nuevo
coplanares y ser simplificado. Pero ajustar el umbral no es fcil. Reddy en usa las caractersticas de la percepcin visual humana para estimar este umbral, pero es ms a menudo dejado al usuario y es an un asunto de prueba y error. Mientras que los algoritmos recientes son mas flexibles que los antiguos, la mayora son apropiados para algunos tipos de objetos, como aquellos usados en aplicaciones mdicas las cuales rara vez tienen bordes pronunciados. Para controlar la simplificacin, el error de aproximacin debera de ser medido localmente (en cada primitiva). Pero para que el usuario sea capaz de especificar la simplificacin, una cota global debera ser puesta para el error. Algunos algoritmos usan una cota para el error local o una distancia a la malla original. Otros usan una construccin geomtrica para asegurar que la simplificacin no exceda un cierto lmite. Un uso para la medida del error es determinar si una simplificacin puede ser usada ya que sus diferencias con el modelo original pueden no ser notables. La mayora de los algoritmos permite al usuario especificar el lmite superior para la aproximacin del error local. Esto no es muy intuitivo y requiere alguna prctica. Alternativamente, algunos algoritmos permiten al usuario especificar cuantos polgonos deberan de ser dejados en la simplificacin. Durante el curso de la simplificacin, una opcin que el algoritmo puede tener es simplificar la topologa. Las simplificaciones pueden conducir a llenar un hoyo o partir un objeto dentro de varias partes no conectadas. Al permitir que la topologa sea modificada deja ms espacio para simplificacin, el resultado es raramente til ya que las diferencias con el objeto original son demasiado notables.
Figura 5.2: Usando LODs para objetos distantes. Es algunas veces interesante permitir que la cantidad de simplificacin vare a travs de la malla, para preservar algunas partes, no obstante simplificar otras ms agresivamente. Esta clase de adaptividad involucra principalmente consideraciones visuales semnticas que pueden ser hechas a priori y son controladas por el usuario. Otros problemas ocurren cuando el tamao del objeto es grande con respecto a la escena. En tales condiciones, alguna parte del objeto estar constantemente en el frente y la mayora del detalle ser siempre usado. El objeto debera de partirse en varias piezas, cada una de las cuales podra tener un nmero de LODs de los cuales escoger. Sin embargo, no hay manera universal de partir el objeto y la continuidad deber ser mantenida entre dos piezas
93
Marta Garca Nuevo
adyacentes as que no aparezcan errores cuando dos piezas son simplificadas independientemente. El algoritmo de simplificacin deber tomar cuidado de esto.
5.2 Simplificacin poligonal

Unos pocos operadores simples puede ser usado para remover primitivas de un modelo:
Normalizacin: remocin de caras degeneradas o bordes y cualquier primitiva definida mltiples veces. Simplificacin de Vrtices: combinacin de todos los puntos incluidos dentro de un volumen (cualquiera una esfera o una celda de rejilla). Entonces, los puntos y las caras cercanas son combinadas. Simplificacin de Borde: remocin de todos los bordes ms pequeos que algn umbral. Simplificacin Basada en Angulo: remocin de bordes los cuales forman un ngulo cerrado. Inversamente, los bordes que estn alineados son combinados. Simplificacin del Tamao de la Cara: remocin de todas las caras las cuales tienen un rea ms pequea que algn umbral. Los hoyos pudieran tener que ser llenados. Simplificacin de la Normal de la Cara: combinacin de todas las caras adyacentes con normales casi paralelas.
Estos operadores simples aparecen en paquetes comerciales, sin embargo, ellos deben ser usados dentro de alguna clase de mecanismos de control para guiar la simplificacin. Los algoritmos de simplificacin poligonal caen en tres diferentes categoras: Geometra de la Remocin: Los algoritmos en esta categora producen una versin simplificada de un modelo mediante la seleccin de un nmero de primitivas las cuales deben ser removidas. La seleccin es hecha usando alguna clase de heurstica. Por ejemplo, el algoritmo identifica vrtices los cuales estn cerca de regiones planares. Este criterio es disminuido en cada interaccin hasta que ningn vrtice adicional pueda ser removido. Este tipo de simplificacin es la ms popular entre los algoritmos recientes. Hinker y Cansen usaron esta tcnica con un criterio de planaridad. Muchos de los algoritmos presentados aqu son de esta categora, pero ellos varan en sus opciones de heurstica y su manera de medir la aproximacin del error.
94
Marta Garca Nuevo
Figura 5.3: Geometra de la Remocin
Subdivisin Adaptiva Esta categora construye una simplificacin inicial la cual es la versin ms simple del modelo original. Esta entonces aade ms detalles en el modelo al subdividir este as que se obtiene una cercana al modelo original. Este entonces es subdividido y la posicin de cada nuevo vrtice es cambiada para tener ms cercana a la superficie original. Este tipo de simplificacin no es tan popular como las previas ya que construir la simplificacin inicial no es simple en el caso general.
Figura 5.4: Subdivisin Adaptativa
Muestreo Finalmente, los algoritmos en esta categora escogen un cierto nmero de primitivas que deberan de ser preservadas (como opuesto a la primera categora, la cual escoge primitivas que debern ser removidas). Una manera de seleccionar estas primitivas es haciendo una seleccin pseudoaleatoria, basada en alguna clase de heurstica. Otro mtodo ms poderoso es muestrear el modelo y escoger un representativo nico para cada grupo de la muestra. Por ejemplo, mientras que est embebido el modelo en una rejilla uniforme de 3D, un vrtice puede ser escogido en cada celda para reemplazar todos los otros vrtices en su celda.
95
Marta Garca Nuevo
Figura 5.5: Sampling
5.3 Algoritmos
Se presentan aqu seis algoritmos que fueron introducidos durante los dos ltimos aos. Se realzan sus principales caractersticas y sus opciones con respecto a las caractersticas presentadas en las secciones previas. 5.3.1 Anlisis de Mallas Arbitrarias de Multiresolucin Esto no es realmente un algoritmo de simplificacin, sino un preprocesador para otro algoritmo el cual produce una representacin de multiresolucin de una malla el cual es un geomorfo compacto conteniendo una malla base simple y una serie de coeficientes "wavelet" que son usados para introducir detalles dentro de la malla. De esta representacin, una nueva malla puede usar una subdivisin recursiva (es decir, donde cada tringulo es subdividido usando un operador de particin 4 a 1) hasta que la cantidad deseada de detalle es alcanzada. Semejante malla es encodificada dentro de una representacin de multiresolucin. El algoritmo que se presenta aqu puede ser usado para convertir cualquier malla a una en la cual se tiene la propiedad de subdivisin recursiva.
Figura 5.6: Cuatro pasos en el algoritmo MRA Este algoritmo es uno de subdivisin adaptiva el cual preserva la topologa, pero identifica cualquier forma caracterstica en la malla. El error de aproximacin es medido usando la distancia a la malla original. Los mapas armnicos son usados en varios pasos para parametrizar una malla 3D dentro de una triangulacin planar. El algoritmo tiene cuatro pasos principales:
96
Marta Garca Nuevo
1. Particionamiento: Un diagrama parecido al de Voronoi es construido sobre la malla original (Figura 5.6.1) usando un algoritmo de buscador de trayectoria multisemilla en el grfico dual de la malla (donde los nodos son las caras de la malla y los arcos representan adyacencias y son pesados usando la distancia entre los centros de caras adyacentes). Este diagrama es entonces triangulado usando un mtodo parecido al de Delamay y los mapas armnico para hacer rectos los bordes (Figura 5.6.2). 2. Parametrizacin: el resultado es una malla base (Figura 5.6.3) que es parametrizada usando un mapa armnico. La parametrizacin es forzada a ser continua a travs de las caras para que el nmero de coeficientes "wavelet" sea mnimo. 3. Remuestreo: la malla base es ahora remuestreada usando un operador de divisin 4 a 1 hasta que la malla est en una cierta distancia a la malla original (Figura 5.6.4). Cada paso es parametrizado como en el paso 3. 4. Anlisis de Multiresolucin: la sucesin resultante de mallas es pasada al algoritmo de anlisis de multiresolucin para ser encodificada usando "wavelets". Este algoritmo es atractivo en su formalismo matemtico. Produce un amplio rango de simplificacin y no obstante detalles que pueden ser aadidos en partes especficas de la malla. Pero esto es computacionalmente caro tambin. Adems, extrayendo una malla vlida desde una representacin basada en "wavelet" es caro. 5.3.2 Mallas Progresivas Este algoritmo de remocin geomtrico tambin produce geomorfas y es derivado de un algoritmo mas antiguo. Este busca reas planares y bordes caractersticos. La simplificacin es hecha aplicando un operador colapso de borde, donde un colapso de borde produce un nuevo vrtice removiendo las dos caras y un vrtice. El resultado es una malla de base simplificada y series de particiones de vrtice las cuales son un inverso de los colapsos de borde y son usadas para introducir detalles dentro de la base de la malla. Esto es llamada Malla Progresiva y un amplio nmero de simplificaciones pueden ser extradas de este. La caracterstica mas importante de este algoritmo es que toma en cuenta informacin tal como color, textura, y discontinuidades normales sobre la superficie de cada malla. Las formas importantes del modelo las cuales son representadas por esta clase de informacin (y no por simple geometra) son tambin preservadas. Por ejemplo, la figura muestra como las ventanas de un avin son preservadas.
97
Marta Garca Nuevo
Figura 5.7: Ejemplo de un Malla Progresiva La minimizacin de una funcin de energa es usada para guiar la simplificacin. Esta funcin tiene cuatro trminos. El primero asegura que la malla simplificada permanece cercana a la original. La segunda favorece tringulos con mejores proporciones. El tercer trmino desalienta la simplificacin de discontinuidades de color y textura. Finalmente, el ltimo trmino desalienta la simplificacin de las discontinuidades topolgicas y normales. Los pasos bsicos del algoritmo son estos: 1. Ordenar los bordes usando el mnimo costo de simplificacin. Este costo es medido usando una variacin de la funcin de energa. 2. Aplicar el operador de colapso de bordes para el borde en la cabeza de la lista y registrar la correspondiente particin del vrtice en la estructura de malla progresiva (incluyendo color, textura e informacin normal) 3. La posicin del nuevo vrtice es seleccionado entre los dos vrtices iniciales y el centro del borde, dependiendo sobre el cual uno es el ms cercano a la malla original. 4. Recalcular el costo para los bordes que han sido afectados por el operador y reordenar la lista. 5. Si la lista est vaca o el costo de la siguiente simplificacin excede un cierto lmite, el algoritmo termina y regresa la malla final progresiva. De otra manera, regresa al paso 2. 6. Este algoritmo es relativamente rpido y toma en cuenta el color y la textura, los resultados son usualmente muy buenos. 5.3.3 Aproximacin de Rango Completo de Poliedros Triangulados Este algoritmo de remocin geomtrica preserva reas planares pero no la topologa. Este usa un operador de regin de combinacin, el cual es burdamente equivalente a un colapso de borde. Uno de los vrtices iniciales es usado como un resultado del operador. El error de aproximacin es medido usando la distancia a la malla original.
98
Marta Garca Nuevo
Semejante al algoritmo previo, este usa una funcin de energa la cual tiene dos trminos. El primero, el error local de teselacin asegura que la orientacin de las normales es preservada y que las nuevas caras no se traslapan. El segundo trmino, el error local geomtrico, preserva a la malla de moverse demasiado lejos de la original. Los pasos bsicos del algoritmo son como sigue: 1. Ordenar todos los bordes respecto a su aumento de costo. 2. Aplicar el operador de combinacin de la regin al primer borde en la lista. 3. Modificar la posicin del vrtice resultante para obtener este ms cercano a la malla original. 4. Recalcular el costo para los bordes modificados y ordenar la lista. El costo es acumulado en cada iteracin as que la simplificacin es ms parejamente distribuida a travs de la malla. 5. Si la lista est vaca o si el costo del siguiente borde es ms alto que un umbral, el algoritmo termina. De lo contrario regresa al paso 2. No obstante las suposiciones bsicas son bastante diferentes, uno puede notar que este algoritmo es muy similar al previo. Este tambin es mucho ms eficiente en preservar las caractersticas de los objetos que lo que fue su antecesor. 5.3.4 Simplificacin por Sobres Este algoritmo de remocin geomtrica preserva reas planares y bordes agudos, tan bien como la topologa. La principal meta de este algoritmo es no usar la medida del error sino solamente la construccin geomtrica para controlar la simplificacin. La Simplificacin por Sobres son dos superficies construidas una de cada lado de la supeficie original usando un distancia (offset) especificada por el usuario y asegurando que estas superficies no se autointersectan. El espacio entre las dos superficies es entonces usado para construir una nueva superficie, la nica restriccin entonces es que los nuevos polgonos no deberan de intersectar con cualquier superficie. Esta reconstruccin puede ser hecha en varias maneras, de las cuales aqu se presentar solamente una. La cantidad de simplificacin es controlada por la distancia (offset) usada para construir las superficies. El caso donde las superficies del sobre son ms probables a intersectarse es a lo largo de los bordes agudos de la malla original, donde no habr mucho espacio para construir una de las superficies. Las superficies que se auto entersectan deben entonces ser movidas mas cercanas a la malla original hasta que la condicin es corregida. Entonces, cerca de los bordes agudos los espacios entre las dos superficies sern mas pequeos y ms pocas simplificaciones sern permitidas. Inversamente, en las reas planares, la distancia ser mxima y as ser la simplificacin.
99
Marta Garca Nuevo
Figura 5.8: Construyendo sobres internos y externos para un tringulo
El algoritmo inicia construyendo los sobres: 1. Distanciar (offset) la superficie externa a lo largo de las normales a los vrtices por una fraccin de la distancia (offset) final deseada. 2. Si, para cualquier vrtice, la superficie se autointersecta, cancelar el movimiento para ese vrtice. 3. Repetir los pasos 1 y 2 hasta que incremento ningn adicional pueda ser alcanzado sin interseccin, o la distancia (offset) haya alcanzado el valor deseado. 4. Repetir los pasos del 1 al 3 para la superficie interna. 5. Repetir los pasos del 1 al 3 para los tubos de los bordes. Estos son construidos a lo largo de los bordes de objetos no cercanos para permitir la simplificacin ah tambin. Esta manera interactiva de construir las superficies distancia (offset) produce resultados no ptimos, es decir los sobres son algunas veces ms cercanos a la malla original que lo que ellos deberan de ser. Calcular la solucin optima requiere evaluar los bordes Voronoi en el espacio 3D, el cual computacionalmente es muy caro. El algoritmo entonces acta generando la malla simplificada. Para cada vrtice de la malla inicial: 1. Remueve el vrtice y las caras adyacentes. 2. Si es posible, iterativamente llenar el hoyo por triangulacin usando las caras ms grandes posibles y asegurando que ellas no se intersectan con las superficies distancias (offset). Si no es posible, cancelar la remocin y tratar el siguiente vrtice.
100
Marta Garca Nuevo
Este algoritmo es atractivo ya que no usa cualquier medida del error. Los sobres son el nico control sobre la simplificacin. Es computacionalmente caro no obstante, especialmente durante la fase de construccin del sobre. 5.3.5 Simplificacin de Superficie Dentro de un Volumen de Tolerancia Este algoritmo de remocin geomtrica, remueve bordes como en A3, pero el control es hecho usando la Tolerancia de Volumen. Pero, en este algoritmo el volumen es construido alrededor de la superficie simplificada y la superficie simplificada es restringida para no permitir a la superficie original salirse del volumen de tolerancia. La cantidad de simplificacin es controlada por el grosor de ese volumen. El volumen de tolerancia es calculado como una esfera alrededor de cada vrtice y representa la acumulacin del error introducido por simplificacin el cual conduce a la creacin del vrtice (por la aplicacin del operador de colapso de borde). Este es entonces interpolado a travs de los bordes y caras Figura 1 y 2 respectivamente). Una de las propiedades agradables del algoritmo es asegurar que el volumen del objeto no es cambiado por la simplificacin (dentro de una tolerancia dada). Esto es muy til para algunos dominios de aplicacin tales como la visualizacin de datos mdicos.
Figura 5.9: La construccin y el mantenimiento del volumen de tolerancia
Los pasos bsicos del algoritmo son los siguientes. La simplificacin inicial es simplemente una copia de la malla original. Los volmenes de error se ponen en valor nulo. Para cada borde por orden de aumento de longitud: 1. Aplicar el operador de colapso de borde. La posicin del nuevo vrtice es calculado al resolver las ecuaciones que aseguran que permanece cercano a la malla inicial y que el volumen es preservado.
101
Marta Garca Nuevo
2. Comprobar que las normales de las caras modificadas no han sido invertidas. Si ellas lo estn, cancelar el colapso del borde e ir al siguiente borde. 3. Comprobar que las nuevas caras tengan buenas proporciones. Esto es evaluado usando una funcin de la superficie y la longitud de los bordes y comprobando que esta funcin no cambie demasiado despus que el operador es aplicado. Si ha cambiado, cancele el colapso del borde e ir al siguiente borde. 4. Actualizar la lista de bordes para tomar en cuenta la modificacin introducida por la simplificacin. 5. Calcular la nueva tolerancia de volumen para que contenga el volumen previo. 6. Si el dimetro del volumen de tolerancia para el nuevo vrtice es ms grande que un umbral dado (es decir, que la malla original no es incluida dentro del volumen de tolerancia), entonces los bordes que comparten este vrtice, son removidos de la lista y ninguna simplificacin adicional tomar lugar en esa rea. A6 - Simplificacin de Malla Este algoritmo de remocin geomtrica es original en que no mide el error de aproximacin, excepto que usa un proceso de agrupamiento para asegurar que la simplificacin es restringida en ciertas reas. Este agrupamiento es hecho mediante la bsqueda de bordes caractersticos y reas planares. Los bordes caractersticos son aquellos que estn compartidos por caras las cuales forman una ngulo ms grande que un umbral dado. Tpicamente, hay muchos bordes caractersticos en reas donde hay pocas caras coplanares.
Figura 5.10: Pasos en el Algoritmo de Simplificacin de Malla Inspirado por A6. El algoritmo hace las siguientes operaciones: 1. Buscar por bordes caractersticos y etiquetar los vrtices usando un nmero de bordes caractersticos que lo comparten. Un vrtice "0" no tiene bordes caractersticos dejando a este.
102
Marta Garca Nuevo
2. Construir agrupamientos de polgonos coplanares. Buscar bordes entre dos vrtices "0" y usar ellos para construir pares de caras coplanares donde los bordes entre dos vrtices "0" no son conectados (Figura 5.10.1). 3. Dentro de cada agrupacin, aplicar un operador de colapso de borde hasta que ninguna simplificacin adicional pueda ser hecha (Figura 5.10.2 a 5.10.4). 4. Buscar bordes de caracterstica colineal dejando vrtices "2", tales como los vrtices sobre los bordes de un cubo (Figura 5.10.4). Esto no puede ser simplificado por un operador de colapso de borde ya que las dos caras adyacentes no son coplanares. Estos bordes son combinados y el vrtice resultante es empujado hacia el otro vrtice. El resultado es mover los vrtices sobre un borde caracterstico hacia sus extremidades (Figura 5.10.5). 5. Buscar vrtices "0" en rodeados por solamente vrtices no "0", como el del centro de un lado de un cubo (Figura 5.10.5). Tales vrtices no pueden ser removidos por el mtodo previo ya que no hay otros vrtices "0" adyacentes para construir un agrupamiento. As que semejantes vrtices son removidos, y el hoyo es triangulado (Figura 5.10.6). Este algoritmo es atractivo por su simplicidad, pero la simplificacin no es siempre ptima. Mejores resultados pueden ser obtenidos gradualmente incrementando los umbrales de planaridad y colinealidad mientras el algoritmo procede.
5.4 Snakes [CHXU]

Los contornos activos o snakes son unos generadores de curvas que se van ajustando a los contornos hasta obtener su lmite o frontera. Este mtodo es usado habitualmente en la visin a travs de computadoras y en el anlisis de imgenes para localizar objetos y describir su contorno. Son mltiples los usos que se pueden dar a este procedimiento. Por ejemplo, una snake puede ser usada para encontrar una zona en concreto en una cadena de montaje, o para encontrar el contorno de un rgano en una imagen mdica, e incluso para automticamente identificar caracteres sobre una carta postal. Segn lo potente que sea la programacin de la snake, ser capaz de resolver grandes problemas, con estos mtodos se han solventado muchos problemas que haban surgido alrededor de la visin por ordenador. Estos problemas eran que las serpientes no podan moverse hacia los objetos que estaban demasiado a lo lejos ni en concavidades divisorias o mellas (como la cima del carcter U), ha costado mucho trabajo resolver esto, porque cuando se propona un mtodo para solucionarlo, surgan problemas nuevos.
103
Marta Garca Nuevo
Figura 5.11: Ejemplo de localizacin de concavidades divisorias Esta snake del ejemplo comienza con el clculo de un campo de fuerzas, llamadas el GVF fuerza, sobre el dominio de imagen. Las fuerzas de GVF son usadas para conducir la serpiente, modelada como un objeto fsico que tiene una resistencia tanto al estiramiento como al doblamiento, hacia las fronteras del objeto. Las fuerzas de GVF son calculadas aplicando ecuaciones de difusin generalizadas a ambos componentes del gradiente de un mapa de borde de imagen.
Figura 5.12: Contornos subjetivos Las fuerzas GVF externas son que hacen esta serpiente intrnsecamente diferente de serpientes anteriores, porque como las fuerzas de GVF son sacadas de una operacin de difusin, tiende a extenderse muy a lo lejos del objeto, esto ampla " la gama de captura " de modo que las serpientes puedan encontrar los objetos que estn bastante a lo lejos de su posicin inicial. Esta misma difusin crea las fuerzas que pueden tirar contornos activos en regiones cncavas. Una diferencia fundamental entre esta formulacin y la formulacin tradicional
104
Marta Garca Nuevo
es que las fuerzas de GVF no son puramente fuerzas irrotacionales (sin rizo). De hecho, normalmente se utilizan tanto campos irrotacionales como campos solenoidales.
Figura 5.13: Imgenes en escala de grises Hemos probado la serpiente GVF sobre muchos tipos de objetos, de formas simples a las imgenes de resonancia magnticas del corazn y el cerebro. Tambin hemos ampliado GVF a tres dimensiones, donde superficies deformables, o globos, son definidas. El objetivo de seguir investigando es usar un globo de GVF tridimensional para encontrar la corteza entera humana cerebral de imgenes de resonancia volumtricas magnticas.
Figura 5.14: Superficies deformables tridimensionales
5.5 Implementacin
Las imgenes que utilizamos en este proyecto contienen gran cantidad de informacin, para ciertas aplicaciones de stas imgenes no es necesaria tanta informacin y slo sirve para hacer que los procesos sean ms lentos y requieran demasiado procesamiento. Es estos casos lo mejor es realizar una aproximacin poligonal de nuestras imgenes para quedarnos slo con la informacin que necesitamos. Para realizar la aproximacin poligonal de las imgenes vamos a utilizar programacin en Matlab, como hemos hecho ya anteriormente.
105
Marta Garca Nuevo
5.5.1 Seleccin de puntos del contorno Para realizar la aproximacin poligonal lo primero que tenemos que hacer quedarnos con los puntos ms significativos del contorno. Para ello lo ms sencillo es pasar nuestras imgenes que estn en niveles de gris a blanco y negro, partiendo de estas imgenes tomaremos puntos del contorno para posteriormente unirlos de manera adecuada. Es necesario que sean detectados los puntos que pertenecen a un mismo objeto, y los que pertenecen a objetos distintos para la conectividad entre los puntos. Para realizar esta seleccin de los puntos usaremos el comando de Matlab BWLABEL, cuya funcin es conectar los puntos de una imagen binaria. Por ejemplo, el comando: L = BWLABEL(BW,N) Devuelve una matriz L, del mismo tamao que la imagen en blanco y negro BW, conteniendo etiquetas de los elementos conectados en BW. Este comando solo admite objetos en dos dimensiones. El parmetro N, puede tener un valor de 4 8, dependiendo de los objetos a conectar. Otro comando que vamos a necesitar es BWLABEL, esta funcin realiza medidas sobre cada una de las regiones que se han etiquetado anteriormente. STATS = IMFEATURE(L,MEASUREMENTS) Marca cada regin etiquetada con un color diferente, STATS es una estructura, los campos de esta estructura son las diferentes medidas de cada regin, segn especifiquemos con el comando MEASUREMENTS. El conjunto de valore vlidos que se puedes dar a este parmetro son los siguientes: 'Area', 'ConvexHull', 'EulerNumber', 'Centroid', 'ConvexImage', 'Extrema', 'BoundingBox', 'ConvexArea', 'EquivDiameter', 'MajorAxisLength', 'Image', 'Solidity', 'MinorAxisLength', 'FilledImage', 'Extent', 'Orientation', 'FilledArea' 'PixelList', 'Eccentricity'. En nuestro programa, lo usamos de la siguiente manera: function stat = AproxPoly (ImBW) [ImLabel,num] = bwlabel(bwperim(ImBW),8) stat=imfeature(ImLabel,'PixelList'); imshow(ImBW,gray(2));
106
Marta Garca Nuevo
De esta manera desplegamos la lista de pxeles que rodean el contorno de nuestras imgenes.
Figura 5.15: Lista de pxeles del contorno de la imagen
5.5.2 Unin de los puntos del contorno Ahora que ya tenemos los puntos que del contorno de nuestras imgenes tenemos que unirlos coherentemente. Dependiendo de la cantidad de puntos que tomemos y de la situacin de esos puntos la exactitud de la aproximacin ser mayor o menor. Es importante que se hayan etiquetado correctamente las regiones para que los puntos se unan encerrando las superficies. Tenemos aqu un ejemplo de una aproximacin demasiado sencilla, tomamos muy pocos puntos del contorno, pero logramos que nos identifique las reas cerradas y que las encierre, aunque sea cometiendo un gran error.
107
Marta Garca Nuevo
Hay que tener cuidado con el modo en que se unen los puntos, determinando distintos criterios de cercana o sentido de la bsqueda del punto siguiente. Realizamos la aproximacin para las rodajas de una en una, porque los comandos que estamos utilizando hasta ahora nos funcionan con tres dimensiones. Para lograr esta sencilla aproximacin el programa que usamos se basa en los comandos anteriormente mencionados, primero etiqueta las superficies que no estn unidas y despus toma puntos del contorno de estas superficies y traza un polgono que las envuelve. function stat = AproxPoly (ImBW) [ImLabel,num] = bwlabel(ImBW); stat=imfeature(ImLabel,'ConvexHull'); stat %Visualizacion imshow(ImBW,gray(2)); hold on; for i=1:size(stat,1) plot([stat(i).ConvexHull(:,1);stat(i).ConvexHull(1,1)],. .. [stat(i).ConvexHull(:,2);stat(i).ConvexHull(1,2)]); end
108
Marta Garca Nuevo
Figura 5.16: Aproximacin con poca exactitud de la rodaja 5
. Figura 5.17: Aproximacin con poca exactitud de la rodaja 35
109
Marta Garca Nuevo
5.5.3 Aproximacin poligonal en 3D Hasta ahora hemos logrado realizar la aproximacin en cada una de las lonchas, lo que vamos a intentar ahora es buscar la continuidad que nuestra pila de imgenes debe poseer. Para ello realizaremos la aproximacin de cada loncha pero asocindola con la aproximacin que se realizar en las lonchas anterior y posterior. Para realizar esta aproximacin tenemos el programa puntos3D2.m, que tomar una variable de Matlab que contenga una pila de imgenes en blanco y negro y realizar su aproximacin poligonal. El programa acta de la siguiente manera, primero etiqueta las regiones de cada loncha, obteniendo los puntos del permetro de cada regin. Ahora estas regiones las seleccionaremos segn tamaos y descartaremos las que sean muy pequeas, grabamos estas regiones rodeadas de por los puntos de su contorno. El siguiente paso es unir estos puntos, para ello usamos el comando snakedisp que inicializa la snake para la aproximacin pero antes de poder usar este comando tenemos que ordenar lo puntos del contorno de las regiones. El programa OrdenarPerimetro.m se encarga de asignar un orden para los puntos que tenemos y as evitar errores en su unin. Desde puntos3D2.m llamamos a OrdenarPerimetro.m cada vez que tenemos etiquetada una loncha y as ordenamos todos los puntos de cada loncha de la variable con la que estemos trabajando. Ahora que ya tenemos todos los puntos ordenados tenemos que ejecutar la snake, para ello hemos escrito el programa snakedisp.m que se encargar de efectuar la representacin grfica de las aproximaciones poligonales de cada loncha. Para ejecutar esta aproximacin en dos dimensiones y media, lo primero que tenemos que hacer es crearnos una variable en blanco y negro, que contenga las lonchas sobre las que queremos ejecutar el programa. Una vez creada esta variable comprobamos que est en el workspace de Matlab.
Figura 5.18: Workspace de Matlab
110
Marta Garca Nuevo
Visto que tenemos la variable creada, nos aseguramos que tenemos los tres programas necesarios, Puntos3D2.m, OrdenarPerimetro.m y snakedisp.m en Current Directory de Matlab.
Figura 5.19: Current Directory de Matlab Si todo es as no debe haber ningn problema para ejecutar el programa, en la command window de Matlab teclearemos; >> puntos3D2(a,'new');
Figura 5.20: Ejecucin del programa puntos 3D2 en Matlab
111
Marta Garca Nuevo
Se ejecutar el programa, que guardar en el directorio actual un fichero de texto con la informacin de los puntos que forman los objetos de cada rodaja. Se desplegar una ventana con la imagen de la primera loncha del fichero con su aproximacin poligonal superpuesta y cuando pulsemos la barra espaciadora veremos la siguiente imagen y as sucesivamente hasta finalizar la visualizacin de la pila de imgenes que contiene nuestra variable. Mostramos a continuacin algunas de las imgenes que son desplegadas:
112
Marta Garca Nuevo
Figura 5.21: Sucesin de imgenes creadas por Puntos3D2.m
Vemos que los resultados de este programa son muy representativos, podemos observar que los contornos de las primeras son muy pequeos, y que van aumentando de tamao segn vamos llegando a las lonchas centrales del fichero, y a partir la loncha central vuelven a reducirse los contornos. Es fcil darnos cuenta con estos resultados de que s hay continuidad en la materia. Mostramos ahora algunas imgenes indicando la loncha a la que corresponden, mostrando slo la aproximacin poligonal y no la imagen inicial, podemos observar lo comentado anteriormente.
113
Marta Garca Nuevo
Figura 5.22: Aproximacin rodaja 2
Figura 5.23: Aproximacin de la rodaja 11
114
Marta Garca Nuevo
115
Marta Garca Nuevo
116
Marta Garca Nuevo
5.6 Conclusiones
Nuevos algoritmos de simplificacin poligonal son ahora capaces de producir niveles satisfactorios de detalles con respecto a los requerimientos visuales y geomtricos. Sin embargo, no importa el algoritmo que sea usado, mucha prctica es todava requerida antes de ser capaz de predecir la cantidad de simplificacin y especificar los valores correctos para los varios parmetros. Adems, los algoritmos no usan la caractersticas de la percepcin humana visual para poner estos parmetros. La generacin de LOD permanece mucho como una actividad de modelacin. Por otro lado, la complejidad de los objetos involucrados en simulaciones de realidad virtual aumenta cada da. La informacin de textura y luz (tal como la producida por el clculo de la radiosidad) es aadida para producir presentaciones mas realstas. Entonces los algoritmos deben evolucionar para tomar en cuenta esta informacin y adaptarlos durante el proceso de simplificacin. Finalmente, la creacin y seleccin de LODs debera de ser integrada a tcnicas de administracin de escenas [5]. El clculo de la relacin de la particin y la visibilidad de escena puede ayudar a la simplificacin en la seleccin de la cantidad de simplificacin que es requerida para una escena particular.
117
Marta Garca Nuevo
118
Marta Garca Nuevo
Procesamiento distribuido
Procesamiento distribuido[ENZO]
En este captulo vamos a describir modos y ventajas de realizar un cluster, enfocndolo sobre todo a lograr el procesamiento distribuido. De esta manera trataremos de ahorrar tiempo y capacidad computacional para ejecutar los programas que se han implementado en captulos anteriores de el proyecto. El concepto de cluster naci cuando los pioneros de la supercomputacin intentaban difundir diferentes procesos entre varias computadoras, para luego poder recoger los resultados que dichos procesos deban producir. Con un hardware ms barato y fcil de conseguir se pudo perfilar que podran conseguirse resultados muy parecidos a los obtenidos con mquinas mucho ms costosas. La unidad bsica de un cluster es un PC convencional que se puede comprar en cualquier tienda. Esta unidad bsica recibe el nombre de nodo. Necesitaremos muchos ordenadores individuales que trabajen en paralelo para reunir una capacidad de clculo respetable, usaremos los ordenadores del laboratorio para construir el cluster, estos nodos estar interconectados usando la tecnologa Ethernet.
Figura 6.1: Cluster como cmulo de PCs
119
Marta Garca Nuevo
Usando varios PCs, trataremos de darles tanta capacidad de procesamiento como si se tratase de un gran servidor . Tendremos la posibilidad de monitorear la carga de CPU, memoria RAM, uso de Discos, etc., de cada uno de los nodos que componen el cluster. De este modo podemos tener un control total del funcionamiento del conjunto, y evitar sobrecarga en los nodos, detectar mal funcionamiento, derivar procesos de manera optima, entre otros. Habr que comentar las herramientas de administracin y gestin que vamos a utilizar. Pues con el paso del tiempo se han ido desarrollando y perfeccionando libreras y programas de cdigo abierto que se han ido encargando de estos temas. En este apartado destacan libreras de paso de mensajes como MPI y PVM.
6.1 Linux [PHPB] [GLUS]

En la actualidad existen una gran cantidad de sistemas operativos dependiendo del tipo de ordenador en el que se va a ejecutar. Por ejemplo para los PC uno de los sistemas operativos ms difundidos en Microsoft Windows, tanto en las versiones 95, 98, 2000 y NT 4.0. Otros posibles sistemas operativos para este tipo de ordenadores son Solaris, OS/2, BeOS, Microsoft DOS, o uno de los sistemas operativos ms poderosos y en rpida expansin para PC, LINUX.
6.1.1
Qu es LINUX?
Linux es un sistema operativo gratuito y de libre distribucin inspirado en el sistema Unix, escrito por Linus Torvalds con la ayuda de miles de programadores en Internet. Unix es un sistema operativo desarrollado en 1970, una de cuyas mayores ventajas es que es fcilmente portable a diferentes tipos de ordenadores, por lo que existen versiones de Unix para casi todos los tipos de ordenadores, desde PC y Mac hasta estaciones de trabajo y superordenadores. Al contrario que otros sistemas operativos, como por ejemplo MacOS (Sistema operativo de los Apple Macintosh), Unix no est pensado para ser fcil de emplear, sino para ser sumamente flexible. Por lo tanto Linux no es en general tan sencillo de emplear como otros sistemas operativos, aunque, se estn realizando grandes esfuerzos para facilitar su uso. Pese a todo la enorme flexibilidad de Linux y su gran estabilidad ( y el bajo coste) han hecho de este sistema operativo una opcin muy a tener en cuenta por aquellos usuarios que se dediquen a trabajar a travs de redes, naveguen por Internet, o se dediquen a la programacin. Adems el futuro de Linux es brillante y cada vez ms y ms gente y ms y ms
120
Marta Garca Nuevo
empresas (entre otras IBM, Intel, Corel) estn apoyando este proyecto, con lo que el sistema ser cada vez ms sencillo de emplear y los programas sern cada vez mejores.
Figura 6.3: Logo de Linux Las distribuciones ms conocidas son RedHat, Debian, Slackware, SuSE y Corel Linux, todas ellas incluyen el software ms reciente y empleado lo cual incluye compiladores de C/C++, editores de texto, juegos, programas para el acceso a Internet, as como el entorno grfico de Linux X Window. Una distribucin es un agrupamiento del ncleo del sistema operativo Linux (la parte desarrollada por Linus Torvalds) y otra serie de aplicaciones de uso general o no tan general. En principio las empresas que desarrollan las distribuciones de Linux estn en su derecho al cobrar una cierta cantidad por el software que ofrecen, aunque en la mayor parte de las ocasiones se pueden conseguir estas distribuciones desde Internet, de revistas o de amigos, siendo todas estas formas gratuitas y legales. 6.1.2 Trabajando con Linux Al contrario que otros sistemas operativos, por defecto el trabajo con Linux no se realiza de una forma grfica, sino introduciendo comandos de forma manual. Linux dispone de varios programas que se encargan de interpretar los comandos que introduce el usuario y realiza las acciones oportunas en respuesta. Estos programas denominados shell son el modo tpico de comunicacin en todos los sistemas Unix incluido Linux. Para muchas personas el hecho de tener que introducir los comandos de forma manual les puede parecer intimidante y dificultoso, aunque como se ver ms adelante los comandos de Linux son relativamente simples y muy poderosos. No obstante, casi todas las distribuciones ms recientes incluyen el sistema X Window (no X Windows), el cual es el encargado de controlar y manejar la interfaz de usuario. Como se ver ms adelante X Window es mucho ms poderoso que otros
121
Marta Garca Nuevo
entornos similares como Microsoft Windows, puesto que permite que el usuario tenga un control absoluto de la representacin de los elementos grficos. Linux es un sistema operativo multitarea y multiusuario. Esto quiere decir que es capaz de ejecutar varios programas (o tareas) de forma simultnea y albergar a varios usuarios de forma simultnea. Por lo tanto, todos los usuarios de Linux deben tener una cuenta de usuario en el sistema que establezca los privilegios del mismo. A su vez Linux organiza a los usuarios en grupos de forma que se puedan establecer privilegios a un determinado grupo de trabajo, para el acceso a determinados archivos o servicios del sistema. Al contrario que lo que ocurre con Microsoft Windows la instalacin de Linux no es un proceso sencillo, puesto que Linux permite el control y la personalizacin de una cantidad mayor de parmetros y opciones. Pese a todo se estn realizando grandes progresos buscando que la instalacin de Linux sea un proceso lo menos traumtico posible, dependiendo la sencillez de la misma de la distribucin que se emplee. Por el momento la distribucin ms sencilla de instalar es Red Hat y aquellas que derivan de esta (Linux Mandrake, ). Existe un concepto fundamental a la hora de instalar y usar Linux que es el de Super Usuario o usuario root. Este usuario es el administrador del sistema y se crea durante la instalacin. Como administrador que es puede acceder y modificar (as como destruir) toda la informacin del sistema, por lo que hay que evitar en la medida de lo posible trabajar como usuario root. El sistema de archivo de Linux sigue todas las convenciones de Unix, lo cual significa que tiene una estructura determinada, compatible y homognea con el resto de los sistemas Unix. Al contrario que en Windows o MS-DOS el sistema de archivos en cualquier sistema Unix no est ligado de una forma directa con la estructura del hardware, esto es, no depende de si un determinado ordenador tiene 1, 2 o 7 discos duros para crear las unidades c:\, d:\ o m:\. Todos el sistema de archivos de Unix tiene un origen nico la raz o root representada por /. Bajo este directorio se encuentran todos los ficheros a los que puede acceder el sistema operativo. Estos ficheros se organizan en distintos directorios cuya misin y nombre son estndar para todos los sistema Unix. X Window es el entorno grfico habitual de los sistemas Unix. El sistema X Window se compone de dos parte principales el servidor X y el programa para la gestin de las ventanas. El servidor X es el programa que se encarga realmente de dibujar en la pantalla. Por el contrario el gestor de ventanas como su nombre indica es el encargado de crear las ventanas y gestionar su apariencia. Debido a este modelo, la apariencia de las aplicaciones vara segn se use uno u otro gestor de ventanas, entre los que destacan por su sencillez de uso los entornos GNOME y KDE.
122
Marta Garca Nuevo
6.1.3 El Shell: comandos bsicos de Linux Hasta este momento se han visto los entornos grficos existentes para Linux ms importantes, no obstante cualquier usuario de Linux acabar antes o despus relacionndose con el sistema empleando el modo texto. Este modo se basa en la ejecucin de una serie de comandos, que son interpretados por un programa o shell. Linux dispone de varios de estos programas pero el ms habitual es conocido como bash o Bourne Shell. Si Linux se ha arrancado en modo texto el sistema arranca de forma directa el shell y queda a la espera de introduccin de nuevos comandos. Si se ha arrancado en modo grfico se puede acceder al shell de dos formas: Se puede acceder al shell del sistema presionando alguna de las siguientes combinaciones de teclas: <ctrl>+<alt>+<F1> <ctrl>+<alt>+<F2> <ctrl>+<alt>+<F3> <ctrl>+<alt>+<F4> <ctrl>+<alt>+<F5> Esto hace que el sistema salga del modo grfico y acceda a alguna de las seis consolas virtuales de Linux, a las cuales tambin se puede acceder cuando se arranca en modo de texto. Para volver al modo grfico hay que presionar <ctrl>+<alt>+<F7> o <ctrl>+<alt>+<F8>. La segunda forma es ms cmoda y menos radical permitiendo acceder al shell desde el mismo entorno grfico. Para esto hay que abrir un programa llamado terminal o consola, por ejemplo: kconsole (en el entorno KDE), xterm, gnome-terminal ( en GNOME), etc como se ha visto anteriormente.
Existen una serie de nociones bsicas que hay que tener en cuenta a la hora de introducir los comandos. En primer lugar citaremos las siguientes: Los comandos hay que teclearlos exactamente. Las letras maysculas y minsculas se consideran como diferentes. En su forma ms habitual (los shells de Bourne o de Korn), el sistema operativo utiliza un signo de $ como prompt para indicar que est preparado para aceptar comandos, aunque este carcter puede ser fcilmente sustituido por otro u otros elegidos por el usuario. En el caso de que el usuario acceda como administrador este signo se sustituye por #.
123
Marta Garca Nuevo
Cuando sea necesario introducir el nombre de un fichero o directorio como argumento a un comando, Linux, permite escribir las primeras letras del mismo y realiza un auto rellenado al presionar la tecla del tabulador. Si no puede distinguir entre diversos casos rellenar hasta el punto en el que se diferencien. Para efectuar el cambio o la introduccin de un password o contrasea se utiliza el comando passwd. A continuacin se describen algunos comandos sencillos de que pueden ser tiles para familiarizarse con los comandos del sistema. date cal 1949 Muestra por pantalla el da y la hora. Muestra el calendario del ao 1949. Muestra el calendario de mayo de 1949.
cal 05 1949 who
Indica qu usuarios tiene el ordenador en ese momento, en qu terminal estn y desde qu hora. Indica cul es la terminal y la sesin en la que se est trabajando.
whoami
man comando Todos los manuales de Linux estn dentro del propio sistema operativo, y este comando permite acceder a la informacin correspondiente al comando comando. clear Este comando limpia la consola
Como se ha visto anteriormente el directorio personal es un directorio con un determinado nombre asignado a un usuario. Los directorios personales habitualmente son subdirectorios de /home (en algunos casos se utiliza mnt, u otro subdirectorio de orden inferior). Generalmente el nombre coincide con el del nombre de usuario, aunque puede no ser as, y varios usuarios pueden estar trabajando en el mismo directorio. Cada usuario de Linux puede crear una estructura en rbol de subdirectorios y archivos tan compleja como desee bajo su directorio personal pero normalmente nunca fuera de l. Una de las acciones ms habituales a la hora de trabajar es mostrar el contenido de un directorio, como se ha visto existen herramientas grficas con este fin, no obstante el shell incluye un programa con este mismo fin: ls que muestra los nombres de los ficheros y subdirectorios contenidos en el directorio en el que se est. El comando mkdir (make directory) permite a cada usuario crear un nuevo subdirectorio:
124
Marta Garca Nuevo
mkdir subdir1 donde subdir es el nombre del directorio que se va a crear. Este comando borra uno o ms directorios del sistema (remove directory), siempre que estos subdirectorios estn vacos. Por ejemplo: rmdir subdir1,donde subdir es el nombre del directorio que se va a eliminar. Este comando permite cambiar de directorio a partir del directorio actual de trabajo. Por ejemplo, cd /home/Pedro En este ejemplo pasamos del directorio actual de trabajo al nuevo directorio /home/Pedro, que ser desde ahora nuestro nuevo directorio. cd dire nos traslada al subdirectorio dire subdirectorio en el directorio actual). (que deber existir como
cd .. Retrocedemos un nivel en la jerarqua de directorios. Por ejemplo, si estamos en /home/Pedro y usamos este comando, pasaremos al escalafn inmediatamente superior de la jerarqua de directorios, en este caso a /home. Nota: al contrario que en MS-DOS en Linux no existe la forma cd.. sin espacio entre cd y los dos puntos. cd Nos sita nuevamente en el directorio personal del usuario. El comando pwd (print working directory) visualiza o imprime la ruta del directorio en el que nos encontramos en este momento. Este comando es uno de los pocos que no tiene opciones y se utiliza escribiendo simplemente pwd. Linux a diferencia de Windows no utiliza letras ("a:", "c:", "d:", ...) para acceder a las distintas unidades de disco de un ordenador. En Linux para acceder al contenido de una unidad de disco o de un CD-ROM este tiene que haber sido previamente "montado". El montado se realiza mediante el comando mount, con lo que el contenido de la unidad se pone a disposicin del usuario en el directorio de Linux que se elija. Por ejemplo para acceder al CD-ROM se tecleara el siguiente comando: mount -t iso9660 /dev/cdrom /mnt/cdrom El comando cp tiene la siguiente forma, cp file1 file2 y hace una copia de file1 y le llama file2. Si file2 no exista, lo crea con los mismos atributos de file1. Si file2 exista antes, su contenido queda destruido y es sustituido por el de file1. El fichero file2 estar en el mismo directorio que file1. Tanto file1 como file2 indican el nombre de un archivo, que puede incluir el la ruta al mismo si alguno de ellos no se encuentra en el directorio actual.
125
Marta Garca Nuevo
cp file1 file2 namedir, que hace copias de file1 y file2 en el directorio namedir. mv file1 file2 El comando mv realiza la misma funcin que el anterior (cp) pero adems destruye el fichero original. En definitiva traslada el contenido de file1 a file2; a efectos del usuario lo que ha hecho es cambiar el nombre a file1, llamndole file2. De igual forma,mv file1 file2 namedir traslada uno o ms ficheros (file1, file2,...) al directorio namedir conservndoles el nombre. El comando, mv namedir1 namedir2 cambia el nombre del subdirectorio namedir1 por namedir2. Hay que recalcar que el comando mv sirve as mismo para cambiar el nombre de los ficheros. En Linux un mismo fichero puede estar repetido con ms de un nombre, ya que con el comando cp se pueden realizar cuantas copias se desee del fichero. Pero, a veces, es ms prctico tener un mismo fichero con varios nombres distintos, y lo que es ms importante, poder acceder a l desde ms de un directorio. En Linux esto recibe el nombre de enlaces mltiples a un fichero. El ahorro de espacio de disco es importante al poder compartir un fichero ms de un usuario. Estos enlaces son muy prcticos a la hora de utilizar ficheros que pertenecen a directorios distintos. Gracias a los enlaces se puede acceder a muchos ficheros desde un mismo directorio, sin necesidad de copiar en ese directorio todos esos ficheros. La forma de este comando es, ln file1 file2. A partir de este momento el fichero file1 tiene dos nombres: file1 y file2. A diferencia de los comandos cp y mv, este comando toma ms precauciones, ya que advierte previamente si el nombre file2 est ocupado, y en este caso no se ejecuta. ln panacea subdir/panacea rm file1 file2 Este comando elimina uno o ms ficheros de un directorio en el cual tengamos permiso de escritura. Con este comando resulta facilsimo borrar ficheros intiles, y desgraciadamente, tambin los tiles. Por eso es conveniente y casi imprescindible emplear lo opcin -i, de la forma siguiente: rm -i file1 file2 Con esta opcin, Linux pedir confirmacin para borrar cada fichero de la lista, de si realmente se desea su destruccin o no. Se recomienda usar siempre este comando con esta opcin para evitar el borrado de ficheros tiles. Por ejemplo, si se teclea, rm -i superfluo, aparecer en pantalla el aviso siguiente:
126
Marta Garca Nuevo
remove superfluo? y habr que contestar y (yes) o n (not). Este comando realiza una serie de comprobaciones en un fichero para tratar de clasificarlo. Su formato es: file fich Tras su ejecucin este comando muestra el tipo del fichero e informacin al respecto del mismo. Los permisos de cada fichero se pueden ver con el comando ls -l. Para cambiar los permisos de un fichero se emplea el comando chmod, que tiene el formato siguiente: chmod [quien] oper permiso files Este comando permite visualizar el contenido de uno o ms ficheros de forma no formateada. Tambin permite copiar uno o ms ficheros como apndice de otro ya existente. Algunas formas de utilizar este comando son las siguientes, cat filename, saca por pantalla el contenido del fichero filename. El comando less es muy similar al anterior pero permite el desplazamiento a lo largo del texto empleando las teclas de cursores pudiendo desplazarse hacia arriba o abajo de un fichero. El comando grep localiza una palabra, clave o frase en un conjunto de directorios, indicando en cules de ellos la ha encontrado. Este comando rastrea fichero por fichero, por turno, imprimiendo aquellas lneas que contienen el conjunto de caracteres buscado. Si el conjunto de caracteres a buscar est compuesto por dos o ms palabras separadas por un espacio, se colocar el conjunto de caracteres entre apstrofes ('). Su formato es el siguiente: grep 'conjuntocaracteres' file1 file2 file3, siendo 'conjuntocaracteres' la secuencia de caracteres a buscar, y file1, file2, y file31 los ficheros donde se debe buscar. Tanto el comando tar como gzip son ampliamente empleados para la difusin de programas y ficheros en Linux. El primero de ellos agrupa varios ficheros en uno solo o archivo, mientras que el segundo los comprime. En conjunto estos dos programas actan de forma muy similar a programas como Winzip. Para crear un nuevo archivo se emplea:
127
Marta Garca Nuevo
tar cvf nombre_archivo.tar fichero1 fichero2 donde fichero1, fichero2 etc. son los ficheros que se van a aadir al archivo tar. Si se desea extraer los ficheros se emplea: tar xpvf nombre_archivo.tar fichero1 Al contrario que tar que agrupa varios ficheros en uno, gzip comprime un nico fichero con lo que la informacin se mantiene pero se reduce el tamao del mismo. El uso de gzip es muy sencillo gzip fichero, con lo que se comprime fichero (que es borrado) y se crea un fichero con nombre fichero.gz. Si lo que se desea es descomprimir un fichero se emplea entonces: gzip d fichero.gz, recuperando el fichero inicial. Como se ha comentado al principio es tpico emplear tar y gzip de forma consecutiva, para obtener ficheros con extensin tar.gz o tgz que contienen varios ficheros de forma comprimida (similar a un fichero zip). El comando tar incluye la opcin z para estos ficheros de forma que para extraer los ficheros que contiene: tar zxf fichero.tar.gz El comando lpr se emplea para imprimir una serie de ficheros. Si se emplea sin argumentos imprime el texto que se introduzca a continuacin en la impresora por defecto. Por el contrario, lpr nombre_fichero, imprime en la impresora por defecto el fichero indicado. 6.1.4 Ejecucin de Programas Para ejecutar un programa en el fondo, es decir, recuperando inmediatamente el control del terminal, basta aadir el carcter & al final del comando de ejecucin: program <datos.d >resultados.r &, inmediatamente aparecer en el terminal, debajo de esta lnea, un nmero que es el nmero de proceso de la ejecucin de este programa. Para detener definitivamente dicha ejecucin (no se puede detener temporalmente) se puede utilizar el comando kill: kill nmerodeproceso
128
Marta Garca Nuevo
La ejecucin de un programa en el fondo no impide que aparezcan en la pantalla los mensajes de error que se produzcan (a no ser que se haya redirigido la salida de errores), y que el programa se pare cuando se salga del sistema. Para que el programa contine ejecutndose an cuando nosotros hayamos terminado la sesin, hay que utilizar el comando nohup: nohup program Si no se utilizan redirecciones todas las salidas del programa se dirigen a un fichero llamado nohup.out. Cuando se utiliza nohup el ordenador entiende que el usuario no tiene prisa y automticamente disminuye la prioridad de la ejecucin. Existe un comando, llamado nice, que permite realizar ejecuciones con baja prioridad, es decir se le indica al ordenador que puede ejecutar de forma ms lenta esta aplicacin si existen otras que sean ms urgentes. Se utiliza en las formas, nice program & nice nohup program & Para darle al programa la prioridad mnima habra que utilizar el comando, nice -19 program &, donde el -19 indica la mnima prioridad. El comando time, precediendo a cualquier otro comando, suministra informacin acerca del tiempo total empleado en la ejecucin, del tiempo de CPU utilizado por el programa del usuario, y del tiempo de CPU consumido en utilizar recursos del sistema. Por ejemplo para saber el tiempo utilizado en la compilacin y montaje del programa prueba.c utilizaramos el comando, time gcc prueba.c Linux incluye una aplicacin llamada top cuya finalidad es manipular la ejecucin de programas de una forma interactiva. Esta aplicacin muestra una lista de los procesos que se estn ejecutando. Los principales comandos de top son: u que muestra los procesos que pertenecen a un determinado usuario, k equivalente al comando kill para matar un proceso y h que muestra la ayuda del programa. El sistema operativo Linux, al igual que otros sistemas operativos, permite realizar programas de comandos, esto es, programas constituidos por distintos comandos que podran teclearse interactivamente uno por uno en una terminal, pero que es muchas veces ms cmodo agruparlos en un fichero, y ejecutarlos con una sola instruccin posteriormente. Los comandos de Linux pueden ser externos - que implican la creacin de un nuevo proceso, cuyo cdigo est en /bin o /usr/bin- e internos - cuyo cdigo est incluido en el del intrprete shell que los ejecuta. Una cierta primera forma de agrupar comandos la ofrece Linux por medio del carcter. Por ejemplo, tecleando el comando,
129
Marta Garca Nuevo
date; ls; who el ordenador ejecutar sucesivamente los comandos date, ls y who. Tambin podra crearse con un editor de textos un fichero llamado comandos que contuviera las lneas siguientes: date ls who Para ejecutar este fichero de comandos puede teclearse, sh comandos o bien convertir el fichero comandos ejecutable por medio del comando chmod en la forma, en directamente
chmod a+x comandos de modo que el programa de comandos comandos puede ejecutarse simplemente tecleando su nombre, comandos. Los comandos sh comandos y comandos no son enteramente equivalentes. As, el primero de ellos exige que el fichero comandos est en el directorio de trabajo, mientras que el segundo slo exige que el fichero comandos est en uno de los directorios de bsqueda de comandos especificados en la variable PATH. Cuando se ejecuta un fichero de comandos Linux abre lo que se llama un nuevo shell, es decir un nuevo entorno para la ejecucin de los comandos. Para que las variables del caparazn original conserven su valor en el nuevo caparazn es necesario prepararlas con la sentencia export antes de abrir el nuevo shell. Por ejemplo, como consecuencia de lo que se acaba de decir, si en el interior de un fichero de comandos se cambia de directorio con el comando cd, al acabar la ejecucin de dicho fichero volveremos automticamente al directorio inicial. Para introducir lneas de comentarios en un programa de comandos basta comenzar dichas lneas con el carcter #. Hay que tomar la precaucin de que este carcter no sea el primer carcter del fichero de comandos, porque entonces el ordenador interpreta que el programa est escrito en Cshell (una variante especial de UNIX desarrollada en la Universidad de Berkeley) y el resultado es imprevisible. Puede ser buena prctica comenzar todos los ficheros de comandos con una lnea en blanco. El comando echo imprime un determinado texto en la terminal. Un ejemplo de utilizacin de dicho comando puede ser el siguiente: echo Me gusta el sistema operativo UNIX El comando echo es de gran utilidad en los ficheros de comandos. Cuando el texto que se desea escribir en la terminal contiene alguno de los caracteres especiales de UNIX ( * ? [ ] > >> < & ; \ ' ) hay que tomar precauciones especiales desconectando su significado. Una forma de hacerlo es precediendo dicho carcter con la barra invertida (\). As, para escribir mediante el comando echo tres asteriscos, utilizaramos
130
Marta Garca Nuevo
echo \*\*\* si no utilizramos la barra invertida, el asterisco se interpretara como un carcter de sustitucin y se imprimira el nombre de todos los ficheros del directorio. Otra forma de anular el significado de los caracteres especiales es encerrando el texto a escribir mediante comillas (") o entre apstrofos normales ('). Los apstrofos (') anulan el significado de todos los caracteres comprendidos entre ellos. As pues, el triple asterisco lo podramos escribir con el comando, echo '***' Las comillas (") son menos restrictivas, y anulan el significado de todos los caracteres excepto los tres siguientes: ( ` \). Esto es muy importante porque si VAR es el nombre de una variable, y VAR aparece en un comando echo entre apstrofos se escribe VAR, mientras que si aparece entre comillas se escribe el valor de la variable, al cumplir el carcter su cometido. El carcter (\) tiene otros significados, adems del ya visto de anular el significado especial de otros caracteres. As, sirve como indicador de que un comando contina en la lnea siguiente. Cuando se utiliza en la definicin interactiva de un comando, en la lnea siguiente aparece el prompt secundario (>), que indica que se debe seguir tecleando el comando. Cuando en un comando echo aparecen los caracteres (\c) y (\n) quiere decir, respectivamente, que no se cambie de lnea y que se salte de lnea, al escribir por la pantalla. El carcter apstrofo inverso o acento grave (`) tiene tambin un significado especial. Cuando en un comando echo aparece el nombre de otro comando encerrado entre apstrofos inversos (por ejemplo, `date`, `who`, `ls`, ...), el nombre de dicho comando se sustituye por el resultado que genera al ejecutarse interactivamente. Un ejemplo podra ser el siguiente: echo "Los usuarios del sistema son \n\n `who`" A los ficheros de comandos pueden pasrseles como parmetros un conjunto de una o ms variables. Dentro del fichero de comandos estas variables o parmetros se conocen con los nombres 0, 1, 2, ..., 9. La variable 0 representa el propio nombre del fichero de comandos, y 1, 2, ..., 9 son los nombres de los parmetros propiamente dichos. Vamos a comenzar viendo un ejemplo muy sencillo de programa de comandos al que se le pasa slo una variable o parmetro. El comando de borrar de Linux rm no confirma la operacin de borrado si no se le pone la opcin (-i). Esto es peligroso porque uno fcilmente puede olvidarse de teclear dicha opcin y borrar lo que no quera borrar. Vamos a crear un fichero de comandos llamado del que incluya dicha opcin. Dicho fichero podra estar formado por, echo "Quiere borrar el fichero 1?" rm -i 1
131
Marta Garca Nuevo
Despus de darle a este fichero el correspondiente permiso de ejecucin con el comando chmod, podramos borrar con confirmacin el fichero file tecleando, del file Los ficheros de comandos tienen muchas ms posibilidades que las que se han apuntado en esta introduccin: pueden leer variables, preguntar por la existencia de un fichero y por si es ejecutable o no, y admiten construcciones lgicas del tipo IF, DO, DO WHILE, etc. Para utilizar estas posibilidades acudir al manual correspondiente. El comando make sirve para organizar la compilacin y el enlazado de programas complicados que dependen de muchos mdulos y libreras diferentes. Cuando se ejecuta este comando, se construye un nuevo ejecutable volviendo a compilar slo aquellos ficheros fuente que son ms recientes que el los ficheros compilados correspondientes, teniendo en cuenta para ello las fechas de ltima modificacin de cada fichero. Este comando se basa en un fichero ASCII (llamado por defecto makefile) que contiene una relacin de dependencias entre los distintos mdulos, as como las acciones que hay que realizar para poner a punto cada mdulo, es decir para pasar de un fuente a un objeto, por ejemplo. Este comando tiene la siguiente forma general: make [f makefilename] [arg_opt] [exe_name] El fichero makefile (con ste o con otro nombre invocado por medio de la opcin f) contiene cuatro tipos de lneas diferentes: Lneas de comentario, que comienzan por el carcter (#). Si en una lnea cualquiera aparece el carcter (#), se ignora todo lo que aparece a continuacin de dicho carcter en dicha lnea. Lneas de definicin de macros. Tienen la forma general, IDENTIFICADOR = cadena_de_caracteres Si en alguna otra lnea aparece (IDENTIFICADOR), dicha ocurrencia se sustituye por cadena_de_caracteres. No es necesario que el nombre del identificador est escrito con maysculas, pero es una costumbre bastante extendida el hacerlo as. Mediante el uso de macros se pueden representar brevemente pathnames o listas de nombres de ficheros largos. Si el identificador tiene una sola letra, no hace falta poner los parntesis. El comando make tiene una serie de macros definidas por defecto que se pueden listar con el comando make p.
132
Marta Garca Nuevo
6.2 OpenMoxis[MCAT]
OpenMosix, un paquete software que posibilita que una red de computadoras basadas en GNU/Linux funcionen como un cluster.
Figura 6.4: Logo de OpenMosix
6.2.1 Breves nociones de OpenMosix El mantenimiento de un sistema resulta incluso ms delicado y costoso (en tiempo) que su correcta instalacin. En este captulo se tomar contacto con todas las herramientas con las que cuenta OpenMosix para poder gestionar tu sistema. OpenMosix proporciona como principal ventaja la migracin de procesos hacia aplicaciones HPC. El adminsitrador puede configurar el cluster utilizando las herramientas de rea de usuario de OpenMosix (OpenMosix-user-space-tools8) o editando la interfcie que encontraremos en /proc/hpc y que ser descrita con ms detalle seguidamente. Los valores en los ficheros del directorio /proc/hpc/admin presentan la configuracin actual del cluster. El administrador del mismo puede configurar estos valores para cambiar la configuracin en tiempo de ejecucin. El demonio de auto-deteccin de nodos, omdiscd, proporciona un camino automtico para la configuracin de nuestro cluster OpenMosix. Con l podremos eliminar la necesidad de configuraciones manuales como son la edicin del fichero /etc/mosix.map . omdiscd genera un envo de paquetes multicast (a todas las direcciones, en nuestro caso, nodos) para notificar a los otros nodos que hemos aadido uno nuevo. Esto significa que al aadir un nodo slo tendremos que iniciar omdiscd en l. Debemos ocuparnos de algunos requisitos previos como pueden ser una buena configuracin de la red de interconexin de los nodos, principalmente para el correcto enrutamiento de paquetes. Sin una ruta por defecto deberemos especificar a omdiscd la interfcie con la opcin -i.
133
Marta Garca Nuevo
Las herramientas del rea de usuario, permitirn un fcil manejo del cluster OpenMosix. Seguidamente se enumeran con todos sus parmetros. La importancia de poder automatizar el reconocimiento de nuevos nodos conectados al sistema ha facilitado que se llegue a la simplicidad con la que contamos actualmente para iniciar dicha deteccin, con el comando omdiscd. 6.2.1.1 Comandos ms utilizados Estas herramientas permitirn un fcil manejo del cluster OpenMosix. Seguidamente se enumeran con todos sus parmetros. migrate [PID] [OpenMosix ID] enva una peticin de migrado del proceso identificado con el ID, al nodo que indiquemos.. mon es un monitor de los daemons basado en el terminal y da informacin relevante sobre el estado actual que puede ser visualizada en diagramas de barras. mosctl es la principal utilidad para la configuracin de OpenMosix. Su sintaxis es: mosctl [stay|nostay] [block|noblock] [quiet|noquiet] [nomfs|mfs] [expel|bring] [gettune|getyard|getdecay] mosct whois [OpenMosix_ID|IP-address|hostname] mosct [getload|getspeed|status|isup|getmem|getfree|getutil] [OpenMosix_ID] mosctl setyard [Processor-Type|OpenMosix_ID||this] mosctlsetspeed interger-value mosctlsetdecay interval [slow fast] Describimos ahora la funcin de algunos comandos sencillos: clear cpujob iojob slow fast stay nostay lstay nolstay block noblock resetea las estadsticas informa a OpenMosix que el proceso est ligado al procesador informa a OpenMosix que el proceso est ligado a la E/S informa a OpenMosix que actualice las estadsticas ms lentamente informa a OpenMosix que actualice las estadsticas ms rpidamente desactiva la migracin automtica migracin automtica (defecto) local processes should stay los procesos locales podrn migrar bloquea la llegada de otros procesos permite la llegada de procesos
134
Marta Garca Nuevo
quiet noquiet nomfs mfs expel bring gettune getyard getdecay whois getload getspeed status isup getmem getfree getutil setyard setspeed setdecay
desactiva la posibilidad de dar informacin sobre la carga del nodo activa la posibilidad de dar informacin sobre la carga del nodo desactiva MFS activa MFS enva fuera del nodo los procesos que han llegado previamente traer todos los procesos migrados hacia su nodo raz muestra el parmetro de overhead muestra la utilizacin actual de Yardstick muestra el estado del parmetro decay nos muestra el OpenMosix-ID, la direccin IP y los nombres de host del cluster muestra la carga (OpenMosix-) muestra la velocidad (OpenMosix-) muestra el estado y la configuracin actual nos informa de si un nodo est funcionando o no (ping OpenMosix) muestra la memoria lgica libre muestra la memoria fsica libre muestra la utilizacin del nodo establece un nuevo valor para Yardstick establece un nuevo valor para la velocidad (OpenMosix-) establece un nuevo valor para el intervalo del decay
Con mosrun ejecutaremos un comando especialmente configurado en un nodo establecido. Su sintaxis: mosrun [-h|OpenMosix ID| list of OpenMosix IDs] command [arguments] El comando mosrun puede ser ejecutado con diversas opciones. Para evitar complicaciones innecesarias viene con ciertas pre-configuraciones para ejecutar las tareas con configuraciones especiales de OpenMosix. nomig runhome runon cpujob iojob nodecay carga slowdecay fastdecay ejecuta un programa cuyos procesos no han migrado ejecuta un comando bloqueado en el nodo raz ejecutar un comando el cul ser directamente migrado y bloqueado a cierto nodo informa a OpenMosix que el proceso est ligado a la CPU informa a OpenMosix que el proceso est ligado a la E/S ejecuta un comando e informa al cluster de no refrescar las estadsticas de ejecuta un comando con intervalo de decay grande para acumular en las estadsticas ejecuta un comando con intervalo de decay pequeo para acumular en las estadsticas
135
Marta Garca Nuevo
6.2.2 Cmo construir el cluster Lo primero que tendremos que hacer es comenzar la instalacin de OpenMosix. Podemos bajarnos el software desde varias paginas web, nosotros lo hemos hecho desde: http://kernel.org/pub/linux/kernel/v2.4 El nombre del archivo que debemos bajar desde esta pgina al directorio temporal es linux-2.4.20.tar.gz. Necesitaremos tambin bajarnos las herramientas OpenMosix-2.4.20-20.gz, desde: http://sourceforge.net/project/showfiles.php?group_id=46729 Desde el directorio temporal tecleamos: tar zxvf linux-2.4.20.tar.gz Y de este modo crearemos un nuevo directorio: linux-2.4.20/ , desde este nuevo directorio, teclearemos: zcat .../ OpenMosix-2.4.20-20.gzpatch p1 Ahora debemos cofigurar y compilar el kernel, para ello usaremos los comandos: make xconfig para configurarlo y make dep para compilarlo make bzImage make modules make modules_install Tenemos que instalar las herramientas, slo necesitaremos rpm, para hacerlo pondremos: rpm ivf OpenMosix-tools-0.2.4-1.i386.rpm Configuramos ahora los nodos, debemos indicarle a la computadora dnde va a poder encontrar los nodos que van a formar parte del cluster. # MOSIX CONFIGURATION # =================== # # Each line should contain 3 fields, # mapping IP addresses to MOSIX node-numbers:
136
Marta Garca Nuevo
# 1) first MOSIX node-number in range. # 2) IP address of the above node (or node-name from /etc/hosts). # 3) number of nodes in this range. # # Example: 10 machines with IP 192.168.1.50 - 192.168.1.59 # 1 192.168.1.50 10 # # MOSIX-# IP number-of-nodes # ============================ 1 138.100.101.131 1 2 138.100.100.134 1 3 138.100.100.138 1 Be sure to check the /etc/hosts. It should look like this: 138.100.100.134 jdelacierva.elai.upm.es jdelacierva 127.0.0.1 localhost.localdomain localhost
6.2.2.1 Ejecutamos un ejemplo Vamos a ejecutar ahora un caso real, nos creamos un programa al que vamos a llamar test y lo guardamos en una carpeta temporal. Tenemos tres nodos: Nodo nmero 1 es un Intel Pentium 4, procesador de 2.4 GHz, 512 Mb RAM. Nodo nmero 2 es un Pentium 2, 350 Mhz, 512 Mb RAM. Nodo nmero 3 no lo usamos en el test for x in 1 2 3 4 do awk BEGIN {for(i=0;i<10000;i++)for(j=0;j<10000;j++);} & done Hay que ejecutar esto a travs de chmod 755 test. * 138.100.101.131 (1) ./test Esto significa que para ejecutar el script hemos consumido 109 segundos, solo ha sido usado el nodo 1. Durante el proceso podemos chequear todos los procesos que se estn ejecutando, usando ps:
137
Marta Garca Nuevo
[marta@jdelacierva Documents]$ ps PID TTY TIME CMD 1760 pts/2 00:00:00 bash 1796 pts/2 00:00:09 awk 1797 pts/2 00:00:09 awk 1798 pts/2 00:00:09 awk 1799 pts/2 00:00:09 awk 1800 pts/2 00:00:00 ps (2) runon 2 ./test Ahora todos los procesos estn siendo ejecutados en el nodo 2, consume 649 segundos, vemos que es mucho ms lento que el nodo 1. (3) mosrun -l ./test Los procesos comienzan a ejecutarse en el nodo 1, pero seguidamente comienza la migracin, el tiempo empleado es de 98 segundos. * 138.100.100.134 (4) ./test Ejecutamos el scrip localmente, nos lleva 640 segundos. (5) runon 1 ./test Tarda 123 segundos en completar la ejecucin en el nodo 1, vemos que es ms lento debido al retardo en la transmisin a travs de la red. (6) mosrun -l ./test El proceso comienza el nodo 2, y tras unos instantes comienza la migracin, tarda 109 segundos . Comparando resultados Comparando el test nmero 1 con el nmero 5
138
Marta Garca Nuevo
Vemos que el test 5 es 15 segundos ms lento que el test 1, es un 13% ms lento. Ambos clculos han sido realizados desde el nodo nmero 1, deducimos que el retraso es debito al retardo de la red. Comparando el test nmero 2 con el nmero 4 Ahora ambos clculos han sido hechos desde la computadora ms lenta, el test nmero 4 no necesita trasmitir datos a travs de la red, va algo ms rpido que el test 2. Comparando el test nmero 3 con el nmero 6 El test nmero 3 es ms rpido porque es iniciado en la computadora ms rpida, pasa algo de tiempo hasta que el proceso comienza a migrar, y en este corto periodo de tiempo el nodo nmero 1 hace los clculos ms rpido que el nodo nmero 2. Comparando el test nmero 1 con el nmero 3 El test nmero 3 es un 10% ms rpido, aqu vemos claras las ventajas de OpenMosix, los resultado seran an ms evidentes si las dos computadoras fueran Pentium 4, 2.4Ghz. Comparando el test nmero 4 con el nmero 5 Aqu vemos como OpenMosix reduce mucho tiempo computacional, el test 5 es un 81% ms rpido porque la mayor parte del proceso se ha ejecutado en el nodo1. Comparando el test nmero 4 con el nmero 6 El balance de carga es la razn por la que el proceso 6 es ms rpido que el proceso nmero 4.
Figura 6.5: Principio del test: sin migracin
139
Marta Garca Nuevo
Figura 6.6: Test al cabo de unos instantes: comienza la migracin
Figura 6.7: Visualizacin del proceso con mosmon
Figura 6.8: Visualizacin de la velocidad con mosmon
140
Marta Garca Nuevo
Figura 6.9: Visualizacin de la memoria con mosmon
Figura 6.10: Visualizacin del uso con mosmon
6.3 MPI
MPI (Message-Passing Interface) es una especificacin estndar para las librera de paso de mensajes. PVM / MPI son herramientas que han estado ampliamente utilizadas y son muy conocidas por la gente que se dedica a la supercomputacin. MPI es el estndar abierto de bibliotecas de paso de mensajes. MPICH es una de las implementaciones ms usadas de MPI, tras MPICH se puede encontrar LAM, otra implementacin basada en MPI tambin con bibliotecas de cdigo abierto. PVM (Parallel Virtual Machine) es un primo de MPI que tambin es ampliamente usado para funcionar en clusters. PVM habita en el espacio de usuario y tiene la ventaja que no hacen falta modificaciones en el kernel de Linux, bsicamente cada usuario con derechos suficientes puede ejecutar PVM.
141
Marta Garca Nuevo
6.4 ParaView [EHEL] [LBER]

Mas que una librera, ParaView es una aplicacin escrita en C++ y Tcl/Tk que utiliza algunos componentes de VTK. Desarrollada por encargo del Departamento de Energa USA como parte de su programa VIEW ("Visual Interactive Environment for Weapons Simulation") dentro del programa ASCI ("Accelerated Strategic Computing Initiative". El paquete ha sido diseado originariamente como herramienta para el anlisis de cantidades masivas de datos (del orden de Terabytes) aprovechando las posibilidades de computacin en paralelo. A pesar de la aparatosidad de sus orgenes, dispone de una interfaz flexible e intuitiva as como una arquitectura extensible basada en estndares abiertos (una de las condiciones del Departamento de Energa es que fuese de cdigo abierto -Open Source-).
Figura 6.11: Pantalla de inicio de ParaView
142
Marta Garca Nuevo
Figura 6.12: Ejemplo funcionamiento de ParaView 6.4.1 Argumentos de la lnea de comandos Hay varios comandos que pueden ser utilizados para controlar la ejecucin de ParaView. A continuacin los enumeramos dividindolos en tres categoras: General: --start-empty, -e : Inicia ParaView sin ningn mdulo por defecto. Esta opcin se usa cuando queremos personalizar ParaView y queremos inutilizar todas las fuentes que vienen por defecto filtros, lectores y botones de barra de tareas. --disable-registry, -dr : No use este registro para ejecutar ParaView, selo slo para hacer pruebas. Con esta opcin, ParaView no har caso de todos los ajustes de usuario almacenados y usar los valores por defecto. Ninguno de los ajustes sern salvados. --play-demo, -pd : Ejecuta la demo de ParaView. --help : Visualiza los comando vlidos. Paralelo --use-rendering-group, -p : Use un subconjunto de procesos para renderizar. Esto es til sobre los sistemas/cluster que tienen un nmero limitado de nodos. Permite ejecutar ParaView sobre ms de un nodo. --group-file, -gf : Cuando usamos las opciones de --use-rendering-group, el nmero de nodos dnde realizar la renderizacin, se leen del fichero (usage --groupfile=fname).
143
Marta Garca Nuevo
--use-tiled-display, -td : Duplica el dato final a todos los nodos y el nodo raz muestra 1-n en una demostracin total. Duplicate the final data to all nodes and tile node displays 1-N into one large display. --tile-dimensions-x, -tdx : -tdx=X where X is number of displays in each row of the display. --tile-dimensions-y, -tdy : -tdy=Y where Y is number of displays in each column of the display. Mesa --use-software-rendering, -r : Use software (Mesa) rendering on all nodes. This is useful when the user wants to have a window only on the first node's display. This is accomplished with using this option in combination with the PV_OFFSCREEN environment variable. --use-satellite-software, -s : Use software (Mesa) rendering only on satellite processes. This is useful when the user wants to have a window only on the first node's display. This is accomplished with using this option in combination with the PV_OFFSCREEN environment variable. Furthermore, since the first node uses hardware accelerated rendering, the performance is not compromised when rendering locally. 6.4.2 Ejecucin de ParaView sobre MPI Si compilamos ParaView sobre MPI, ParaView se podr lanzar como cualquier otro uso de MPI. El mtodo para comenzar el uso de MPI depende del sistema y de la implementacin con la que se haya instalado. Una vez que est comenzado, el interfaz de uso aparecer el la pantalla con el proceso (proceso con la identificacin 0). El display de otros procesos (procesos basados en los satlites), aparecern ventanas independientes. stos no tienen asociados interfaces de uso y no se pueden manipular por el usuario. Observamos que todos los procesos tienen un display para visualizarlo. Esto no requiere la presencia de un monitor. Mientras ParaView pueda abrir ventanas de todos los procesos y leer su contenido, funcionar correctamente. Si varios procesos comparten el mismo display, ocurrira como si las ventanas abiertas por estos procesos se solapasen. Si sucede esto, el contenido de esas ventanas no se puede leer por ParaView y la imagen en la ventana principal (la que est con el interfaz de uso) ser errnea. Igualmente pueden suceder si hay otras ventanas que ocultan la parte o toda la ventana de los procesos basados en los satlites. ParaView apoya fuera de la pantalla la representacin en nodos basados en los satlites.
144
Marta Garca Nuevo
6.5 MPICH[DASH]
MPICH es una implementacin frecuente del estndar MPI que corre sobre una gran variedad de aplicaciones. Con la liberacin del estndar MPI, MPICH fue diseado para proporcionar una puesta en prctica del estndar MPI que podra sustituir los sistemas propietarios de paso de mensajes en los enormes ordenadores paralelos de aquellos das. Como MPICH fue diseado para permitir a puertos a otros sistemas, muchos vendedores de ordenadores paralelo y grupos de investigacin han usado MPICH como la base para su implementacin. Muchos usuarios se han familiarizado ahora slo con la versin de MPICH que usa el dispositivo ch_p4 para el puesto de trabajo y el cluster Beowulf. Sin embargo, MPICH sigue apoyando otros sistemas y sigue sirviendo como una plataforma para la investigacin en implementaciones MPI. Vamos a utilizar MPICH bajo Windows, necesitaremos tener en los ordenadores que formarn el cluster WindowsNT/2000/XP Profesional o Server, y necesitaremos tambien hacer conexiones TCP/IP sobre todos los nodos. 6.5.1 Instalacin de MPICH Lo primero que haremos para lograr una correcta instalacin del programa es obtener el archivo mpich.nt.1.2.5.exe. La forma de obtener este archivo es bajndolo de la pgina: www.mcs.anl.gov/mpi/mpich/download.html; Ejecutamos este archivo en todos los ordenadores con los que vamos a construir el cluster, seleccionamos la instalacin por defecto. Tambin es posible realizar una instalacin manual si nos encontrsemos con algn problema en la instalacin por defecto. Si instalamos MPICH en varios nodos tendremos que configurarlos, para ello usaremos la herramienta MPICH Configuration tool. Tendremos que introducir los nodos donde hemos instalado MPICH y pulsar al icono de aplicar para que se guarde la lista de nodos en el registro de Windows y as simplemente con escribir los nombres cuando sean necesarios se seleccionarn los nodos donde ejecutar el proceso. Para salir pulsaremos OK.
145
Marta Garca Nuevo
Figura 6.13: MPICH Configuration tool 6.5.2 Herramientas Describimos en este apartado las funciones de cada una de las herramientas de MPI. 6.5.2.1 mpirun mpirun es el instrumento que se comunica con el lanzador de proceso de mpd para comenzar usos MPI. Viene de dos formas diferentes mpirun y guimpirun. mpirun es la versin en lnea de comandos del instrumento y guimpirun es la versin grfica. La versin en lnea de comando fue desarrollado primero y luego guimpirun implementado sobre este, es la razn por la que el instrumento de lnea de mando es ms estable. A continuacin mostramos un ejemplo del formato de configuracin:
exe c:\somepath\myapp.exe OR \\host\share\somepath\myapp.exe [args arg1 arg2 arg3 ...] [env VAR1=VAL1|VAR2=VAL2|...|VARn=VALn]
146
Marta Garca Nuevo
[dir drive:\some\path] [map drive:\\host\share] hosts hostA #procs [path\myapp.exe] hostB #procs [\\host\share\somepath\myapp2.exe] hostC #procs ...
Las lneas encerradas entre corches son opcionales. Vemos dos modos de configuracin.
exe c:\temp\myapp.exe hosts fry 1 jazz 2
Este otro ejemplo, muestra un escenario ms complicado.

exe c:\temp\slave.exe env MINX=0|MAXX=2|MINY=0|MAXY=2 args -i c:\temp\cool.points hosts fry 1 c:\temp\master.exe fry 1 #light 1 jazz 2
Ambos procesos recibirn, como argumentos de la lnea de comandos:

-i c: n temp n cool.points
6.5.2.2 MPIRegister tool MPIRegister.exe es un instrumento para cifrar una cuenta y la contrasea en el registro para el usuario corriente. Se encuentra en el directorio MPICH\mpd\bin. La informacin que almacena es usada por mpirun para lanzar procesos del usuario especificado. Si no se usa mpiregister entonces mpirun crear una nueva cuenta y contrasea cada vez que sea llamado. 6.5.2.3 Configuration tool Este instrumento es un interfaz grfico, que registra los ajustes que controlan algunas de las opciones de configuracin MPICH. Para ejecutar una aplicacin en varios nodos sin especificarlos en un fichero de configuracin, el lanzador de los procesos debe saber todos los nodos en los que el programa est instalado. MPIConfig.exe puede encontrar a los nodos donde el programa ha sido instalado y escribe esta lista de nodos en el registro. Con esta informacin mpirun puede escoger los nodos de la lista en el registro para determinar donde lanzar los procesos.
147
Marta Garca Nuevo
Figura 6.14: Ejemplo de MPICH Configuration tool Creamos la lista de nodos: La primera seccin del dilogo tiene una lista que tiene que estar llena con los nombres de los nodos donde mpd ha sido instalado. Usamos los botones y/o escribimos los nombres del anfitrin directamente en la ventana para crear la lista. Seleccin de las opciones de configuracin: El la siguiente seccin del dilogo, podemos seleccionar distintas opciones de configuracin, seleccionamos los que nos convengan. Aplicamos los cambios: Pulsamos el botn Apply o Apply single segn nos interese, para que se hagan efectivos los cambios.
148
Marta Garca Nuevo
6.5.2.4 Update tool Esta herramienta permite al administrador bajar las mps y las dlls de mpich en un cluster de mquinas.
Figura 6.15: MPICH Update tool Lo primero que tenemos que hacer es seleccionar la lista de nodos, tras ello seleccionaremos lo que queremos bajar y finalmente aplicaremos los programas obtenidos. 6.5.3 Ejecutamos un ejemplo En este sencillo ejemplo trataremos de ejecutar en programa en un computado trabajando desde otro diferente, y visualizando los resultados del programa en la mquina dnde estamos trabajando. Para ello lo primero que hemos hecho es instalar MPICH en algunos de los ordenadores del laboratorio, construyendo as nuestro cluster, para ello nos ayudamos de la
149
Marta Garca Nuevo
herramienta Configuration tool, donde la lista de nodos que hemos agregado es la siguiente:
Figura 6.16: Ventana de seleccin de nodos Ya tenemos determinados los nodos de los que va a constar nuestro cluster. Visualizamos actualmente como estn los trabajos pendientes y vemos que no los hay.
Figura 6.17: MPICH Job manager
150
Marta Garca Nuevo
Con esta herramienta vemos el estado actual del cluster y podramos cancelar procesos para enviar otro nuevo si fuese necesario. Los que pretendemos en este ejemplo es ejecutar el programa cpi.exe, para ello necesitamos que el programa est ubicado en el mismo directorio en todos los ordenadores que vayan a participar, as que lo guardaremos en el directorio C:\temp\cpi.exe de Copernico y de Fourier que son los nodos que vamos a usar. Estamos trabajando en Copernico, para lograr ejecutar el programa en Fourier, usaremos la herramienta guiMPIRun, como se muestra en la siguiente figura, indicando dnde se encuentra el programa a ejecutar y los nodos que usaremos.
Figura 6.18: guiMPIRun Para ejecutar el programa pulsamos Run y en ese momento comienza la transferencia de informacin a Fourier, al intentar entrar en otro computador, por seguridad de la red del laboratorio, ser necesario introducir una contrasea con ese permiso.
151
Marta Garca Nuevo
Figura 6.19: Ventana de usuario y contrasea Con todo esto logramos que se ejecute el programa remotamente, haciendo trabajar a Fourier y recibiendo los resultados en Copernico.
6.6 Conclusiones
Est claro que el hecho de que el clustering est teniendo tal auge en estos momentos se debe a la confluencia de un cmulo de factores como el abaratamiento del precio, desarrollo y aumento de prestaciones tanto del hardware de los nodos, como de la red de interconexin y herramientas de gestin, etc... Lo visto en este captulo son solo pequeas nociones de la gran potencia computacional que podemos obtener con los grandes clusters que se estn construyendo hoy en da. Pero creo queda suficientemente demostrada la importancia del clustering y el por qu de tan gran auge. El pequeo ejemplo mostrado solo es un pequeo pasito para el trabajo que seguro culminarn con xito compaeros de prximas promociones.
152
Marta Garca Nuevo
ANEXO A
7
[SART] [TWIL] [DADA] [SOTO] [UAMA]
BIBLIOGRAFA
IEEE Transactions On Biomedical Engineering, Vol. 47, No. 12, December 2000. Alessandro Sarti, Carlos Ortiz de Solrzano, Member, IEEE, Stephen Lockett, and Ravikanth Malladi* Confocal Microscopy. T. Wilson. London, U.K. Academic, 1990. D. Adalsteinsson and J. A. Sethian, A fast level set method for propagating interfaces, J. Comp. Phys., vol. 118, no. 2, pp. 269277, May 1995. La Microscopia Confocal. Enrique Soto Eguibar. Centro de Ciencias Fisiolgicas. Instituto de Ciencias Universidad Autnoma de Puebla. http://photonics.cnb.uam.es/Photonic_sp/Review/confocal.htm ORIOS DE MICROFOTONICA Departamento de Inmunologa y Oncologa Centro Nacional de Biotecnologa Universidad Autnoma de Madrid http://www.cnic.es/web_citometria/docs/doc/RESCFCA.DOC Introduccin a La Microscopa Confocal. Aplicaciones en Microbiologa, Alberto
7.1 Microscopio confocal
[AALV]
ANEXO A
Marta Garca Nuevo
lvarez Barrientos, Unidad de Citometra, Centro Nacional de Investigaciones Cardiovasculares, ISCIII, Madrid [ERIC] [LOCI] http://www.physics.emory.edu/~weeks/ Dr. Eric R. Weeks. . 1996-2003 Physics Department, Emory University http://www.loci.wisc.edu/index.html laboratori of optical and computational Istrumentation http://www10.uniovi.es/serv_com/confoc/ext_co.htm Servicio de Proceso de Imgenes Bloque Polivalente A. Julin Clavera. S/N. Universidad de Oviedo
[ABEC]
[ABEC]
http://www.chemie.uni-marburg.de/~becker/image.html Quantitative Image Analysis by NIH Image. Andreas Becker.

http://wellpath.uniovi.es/es/contenidos/seminario/tecnicas_imagen/main.htm..
[JDOB]
Jerzy Dobrucki [JMCU] http://www2.cbm.uam.es/confocal/imagenes.htm. Autores, J. M. Cuezva, M. A. Alonso
7.2 Eliminacin del Ruido

[MWOR] [IPTU] [UMAT] [IIPM] [SDCM] [AMAR] [CNBT] www.mathworks.com Perform image processing, analysis, and algorithm development 2002 by The MathWorks. Image Processing Toolbox Users Guide (R) COPYRIGHT 1993 - 1998 by The MathWorks, Inc. Using MATLAB. COPYRIGHT 1984 - 2002 by The MathWorks, Inc. Introduction to Image Processing in Matlab. By Kristian Sandberg, Department of Applied Mathematics, University of Colorado at Boulder SDC Morphology Toolbox V1.1 1,5 Jan02 La Imagen Digital. ngel Martnez Nistal. http://photonics.cnb.uam.es/ Centro Nacional de Biotecnologa. Madrid.
Marta Garca Nuevo
ANEXO A
[TMAT] [JCHI] [KITW] [FPIC]
http://www.mathworks.es/products/image/ Blind Deconvolution Page. Julian Christou. http://www.kitware.com/ Kitware Inc
The MathWorks, Inc.
Formato Grfico PIC. Por Fco. Mario Hernndez Tejera y J. Javier
Lorenzo Navarro.
7.3 Aproximacin Poligonal

[CHEN] Generalized gradient vector flow external forces for active contours1 Chenyang Xu, Jerry L. Prince2,* http://iacl.ece.jhu.edu/projects/gvf/ Johns Hopkins University & Image Analysis and Communications Lab Copyright 2002-2003 C. Xu, Deformable Models with Application to Human Cerebral Cortex Reconstruction from Magnetic Resonance Images, PhD Dissertation, Department of Electrical and Computer Engineering, Johns Hopkins University, Baltiomre, MD, 21218, USA. http://www.acm.org/crossroads/espanol/xrds3-4/levdet.html Por Mike Krus, Patrick Bourdot,Franoise Guisnel, and Guillaume Thibault Herramienta con Implementacin Orientada a Objetos para Construccin de Mallados Poligonales de Volmenes y Superficies Implcitas. Villegas R.(1), Montilla G.(2),Villegas H.(3), Bosnjak A., Torrealba V. y Paluzny M.(4) http://www.acm.org/crossroads/espanol/xrds3-4/levdet.html Mike Krus is a PhD student of the Univerisity Paris XI, Orsay, France
http://www.ams.sunysb.edu/~piyush/ Piyush Kumar. Dept. of Mathematics,
[JHOP] [CHXU]
[MKRU] [RVIL]
[MKRU] [PKUM] [CHXU]
I.I.T. Kharagpur. September 10, 1998 http://iacl.ece.jhu.edu/ Gradient Vector Flow Chenyang Xu and J.L. Prince
ANEXO A
Marta Garca Nuevo
7.4 Procesamiento distribuido

[ENZO] [OPIN] [LMUR] http://ib.cnea.gov.ar/~ipc/ Enzo A. Dari y Jorge O. Sofo. Febrero 2002. Los Clusters. Por Oscar Pino Morillas, Roberto Francisco Arroyo Moreno y Francisco Javier Nievas Muoz. El Procesamiento Paralelo, Enfoque Cualitativo y Simulacin. Por Leslie Murray. Escuela de Ingeniera Electrnica, Universidad Nacional de Rosario, Argentina. Mayo 26, 2000. Scalable Parallel Computing de Kai Hwang y Khiwei Xu. Operating System Concepts de Silberschatz Galvin. http://www.linuxespanol.com/ Powered by phpBB 2.0.6 2001, 2002 phpBB Gua de Linux Para el Usuario. Copyright Oc 1993, 1994, 1996. Larry Greenfield
[KHWA] [SGAL] [PHPB]

Group
[GLUS]
7.4.1 MPI [FGAR] F. Garca, A . Caldern, J. Carretero MiMPI: A Multithread Implementation of MPI. 6th European PVM/MPI. Users Group Meeting, 207214, Sep 1999. F. Garca, J. Carretero, F. Prez, and P. de Miguel. Evaluating the ParFiSys Cache Coherence Protocol on an IBM SP2. Technical Report FIM/104.1/datsi/98, Facultad de Informtica, UPM, January 1998. http://www.cnb.uam.es/~carazo/practica_mpi.html#Introduccion www.mpiforum.orf/docs/mpi-11.ps Message Passing Interface Forum. MPI: A Message-Passing Interface Standard. 1995.
[PMIG]
[CARA] [MPIS]
7.4.2 Paraview [ACAL] http://www.ibiblio.org/pub/Linux/docs/LuCaS/Presentaciones/1999hispalin ux/conf-acaldero/3.pdf Alejandro Caldern, Flix Garca, Jess Carretero. Octubre de 1999 [EHEL] Author: ehelp Corporation. Copyright (c) 1992-2002. http://wwwvis.lbl.gov/software_support/paraview/docs/HTML/running_paraview_with _mpi.htm
Marta Garca Nuevo
ANEXO A
[PARA] [LBER]
http://www.paraview.org http://www-vis.lbl.gov/software_support/paraview/ The Visualization Group at Lawrence Berkeley National Laboratory. Jun2003.
7.4.3 OpenMosix
[MCAT] [KERN] [NO3D]
http://www.redes-linux.com/manuales/cluster/howToopenMosixES_0.4beta.pdf .Inspirado en el HOWTO de Kris Buytaert http://kernel.org/pub/. This site is operated by the Kernel.Org Organization. Noticias3D.com, (c)2000-2003. http://www.noticias3d.com/articulos/200305/cluster/2.asp
7.4.4 Mpich [DASH] [MPIC] Installation and Users Guide to MPICH, by David Ashton, William Gropp, and Ewing Lusk http://www-unix.mcs.anl.gov/mpi/mpich/
ANEXO A
Marta Garca Nuevo
Marta Garca Nuevo
ANEXO B
ndice de figuras
8.1 Estado de la Tcnica.

Figura 2.1: Imagen del confocal Figura 2.2: Esquema del microscopio confocal Figura 2.3: Microscopio confocal real Figura 2.4: Ejemplo del uso de luces Figura 2.5: Imagen de barrido de un cultivo de clulas epiteliales Figura 2.6: E. Coliteidas con cloruro de propidio, para observar la condensacin del cromosoma. Figura 2.7: Visualizacin de un organismo en una clula husped.
ANEXO B
Marta Garca Nuevo
Figura 2.8: Dos tipos de clulas vistas en planos diferentes. Figura 2.9: Ejemplo del tipo de filtrado, fotgrafo. Figura 2.9: Ejemplo del tipo de filtrado, estrellas. Figura 2.10: Demo de la reduccin del ruido con Matlab . Figura 2.11: Ejemplo de aproximacin poligonal de una superficie. Figura 2.12: Modelado de una superficie. Figura 2.13: Mallado de una superficie. Figura 2.14: Aproximacin de un contorno. Figura 2.15: Visualizacin de una figura obtenida por Aproximacin Poligonal. Figura 2.16: Sistemas distribuidos. Escalabilidad de servicios. Figura 2.17: Cluster a nivel de sistema y nivel de aplicacin Figura 2.17: Logo de openMosix Figura 2.19: Logo de Linux Figura 2.20: Logo de Linux
8.2 Herramientas de Visualizacin

Figura 3.1: Logo Matlab Figura 3.2: Ejemplo de pantalla de Matlab Figura 3.3: Logo VTK Figura 3.4: Figura procesada con VTK. Figura 3.5: Figura procesada con VTK.
Marta Garca Nuevo
ANEXO B
Figura 3.6: Logo SDC. Figura 3.7: Imagen binarizada y dilatada. Figura 3.8: Imagen procesada con VTK. Figura 3.9: Logo OpenMosix. Figura 3.10: Logo ParaView Figura 3.11: Ejemplo imagen con tratada con SDC. Figura 3.12: Logo MPI Figura 3.13: Logo MPI Reserch.
8.3 Procesamiento
Figura 4.1: Cabecera de los archivos *.PIC Figura 4.2: Seleccin de una ROI Figura 4.3: ROI de nuestra imagen Figura 4.4: Imagen original del microscopio confocal Figura 4.5: Imagen original abierta con mmshow. Figura 4.6: Dilatacin condicionada Figura 4.7: Dilatacin normal Figura 4.8: Resultado usando SDC Figura 4.9: Imagen 3D abierta con VTK Figura 4.10: Volumen renderizado Figura 4.11: Superficie renderizada Figura 4.12: Imagen 3D obtenida con openpic.m
ANEXO B
Marta Garca Nuevo
Figura 4.13: Workspace de Matlab Figura 4.14: Current Directory de Matlab Figura 4.15: 10 lonchas del archivo *.PIC Figura 4.16: Pantalla al ejecutar el programa openpic.m Figura 4.17: Resultado de openpic3D.tcl Figura 4.18: Resultado de picsuper.m Figura 4.19: Resultado de opensup.m Figura 4.20: Resultado de opensupbw.m Figura 4.21: Resultado de opensupbw.m

Figura 5.1: Una sucesin de LODs Figura 5.2: Usando LODs para objetos distantes. Figura 5.3: Geometra de la Remocin Figura 5.4: Subdivisin Adaptativa Figura 5.5: Sampling Figura 5.6: Cuatro pasos en el algoritmo MRA Figura 5.7: Ejemplo de un Malla Progresiva Figura 5.8: Construyendo sobres internos y externos para un tringulo Figura 5.9: La construccin y el mantenimiento del volumen de tolerancia Figura 5.10: Pasos en el Algoritmo de Simplificacin de Malla Inspirado por A6. Figura 5.11: Ejemplo de localizacin de concavidades divisorias
Marta Garca Nuevo
ANEXO B
Figura 5.12: Contornos subjetivos Figura 5.13: Imgenes en escala de grises Figura 5.14: Superficies deformables tridimensionales Figura 5.15: Lista de pxeles del contorno de la imagen Figura 5.16: Aproximacin con poca exactitud de la rodaja 5 Figura 5.17: Aproximacin con poca exactitud de la rodaja 35 Figura 5.18: Workspace de Matlab Figura 5.19: Current Directory de Matlab Figura 5.20: Ejecucin del programa puntos 3D2 en Matlab Figura 5.21: Sucesin de imgenes creadas por Puntos3D2.m Figura 5.22: Aproximacin rodaja 2 Figura 5.23: Aproximacin de la rodaja 11 Figura 5.24: Aproximacin de la rodaja 35 Figura 5.25: Aproximacin de la rodaja 44 Figura 5.26: Aproximacin de la rodaja 57 Figura 5.27: Aproximacin de la rodaja 66

Figura 6.1: Cluster como cmulo de PCs Figura 6.2: Cluster como cmulo de PCs Figura 6.3: Logo de Linux Figura 6.4: Logo de OpenMosix
ANEXO B
Marta Garca Nuevo
Figura 6.5: Principio del test: sin migracin Figura 6.6: Test al cabo de unos instantes: comienza la migracin Figura 6.7: Visualizacin del proceso con mosmon Figura 6.8: Visualizacin de la velocidad con mosmon Figura 6.9: Visualizacin de la memoria con mosmon Figura 6.10: Visualizacin del uso con mosmon Figura 6.11: Pantalla de inicio de ParaView Figura 6.12: Ejemplo funcionamiento de ParaView Figura 6.13: MPICH Configuration tool Figura 6.14: Ejemplo de MPICH Configuration tool Figura 6.15: MPICH Update tool Figura 6.16: Ventana de seleccin de nodos Figura 6.17: MPICH Job manager Figura 6.18: guiMPIRun Figura 6.19: Ventana de usuario y contrasea

Procesamiento

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Procesamiento

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSIDAD POLITCNICA DE MADRID

DEPARTAMENTO DE ELECTRNICA, AUTOMTICA E INFORMTICA INDUSTRIAL

Grupo de Visin Artificial

Procesamiento y Visualizacin Tridimensional de Imgenes Biomdicas del Microscopio Confocal

Nadie sabe de lo que es capaz hasta que lo intenta. Sirio, Publio

La gota horada la roca, no por su fuerza sino por su constancia. Ovidio

Muchas gracias a todos.

Objetivos....................................................................................................... 2 Sumario del proyecto .................................................................................. 3

ESTADO DE LA TCNICA ....................................................... 5

HERRAMIENTAS DE VISUALIZACIN ................................. 45

APROXIMACIN POLIGONAL .............................................. 91

5.3.1 5.3.2 5.3.3 5.3.4 5.3.5 5.4

PROCESAMIENTO DISTRIBUIDO[ENZO] ............................... 119

BIBLIOGRAFA ..................................................................... 153

NDICE DE FIGURAS............................................................ 159

Marta Garca Nuevo

Marta Garca Nuevo

Marta Garca Nuevo

1.2 Sumario del proyecto

Marta Garca Nuevo

Marta Garca Nuevo

Marta Garca Nuevo

2.2 Principios de la microscopa confocal [SART] [TWIL] [DADA]

Marta Garca Nuevo

Figura 2.2: Esquema del microscopio confocal

Marta Garca Nuevo

Marta Garca Nuevo

Figura 2.4: Ejemplo del uso de luces

Marta Garca Nuevo

Marta Garca Nuevo

Marta Garca Nuevo

Figura 2.7: Visualizacin de un organismo en una clula husped.

Imgenes 3D con el microscopio confocal [ABEC]

Figura 2.8: Dos tipos de clulas vistas en planos diferentes.

Marta Garca Nuevo

Limitaciones de la microscopia confocal

2.3 Eliminacin del ruido

Marta Garca Nuevo

Marta Garca Nuevo

Figura 2.9: Ejemplo del tipo de filtrado, fotgrafo.

Figura 2.10: Ejemplo del tipo de filtrado, estrellas.

Marta Garca Nuevo

Marta Garca Nuevo

Figura 2.11: Demo de la reduccin del ruido con Matlab.

Marta Garca Nuevo

Marta Garca Nuevo

2.4 Aproximacin poligonal [CHEN] [CHXU]

Figura 2.12: Ejemplo de aproximacin poligonal de una superficie.

Marta Garca Nuevo

Figura 2.13: Modelado de una superficie.

Marta Garca Nuevo

Figura 2.14: Mallado de una superficie.

Marta Garca Nuevo

Marta Garca Nuevo

Figura 2.16: Visualizacin de una figura obtenida por Aproximacin Poligonal.

Marta Garca Nuevo

2.5 Procesamiento distribuido [ENZO] [OPIN]

Marta Garca Nuevo

Marta Garca Nuevo

Marta Garca Nuevo

Marta Garca Nuevo

Marta Garca Nuevo

RPC: RMI: CORBA: Bonobo: KDE: SOAP: DCOM:

Marta Garca Nuevo