UNIVERSIDAD DE CHILEFACULTAD DE CIENCIAS FISICAS Y MATEMATICASDEPARTAMENTO DE CIENCIAS DE LA COMPUTACION

DESARROLLO DE UNA HERRAMIENTA QUE GENERAMALLAS DE SUPERFICIE COMPUESTAS DE

CUADRILATEROS PARA MODELAR EL CRECIMIENTODE ARBOLES

MEMORIA PARA OPTAR AL TITULO DE INGENIERO CIVIL ENCOMPUTACION

CRISTINA SONIA MELO LAGOS

PROFESOR GUIA:NANCY HITSCHFELD KAHLER

MIEMBROS DE LA COMISION:MARIA CECILIA RIVARA ZUNIGAPATRICIO INOSTROZA FAJARDIN

SANTIAGO DE CHILEABRIL 2008

RESUMEN DE LA MEMORIA

PARA OPTAR AL TITULO DE

INGENIERO CIVIL EN COMPUTACIONPOR: CRISTINA MELO LAGOSFECHA: 21/04/2008

PROF. GUIA: NANCY HITSCHFELD K.

Desarrollo de una herramienta que genera mallas desuperficie compuestas de cuadrilateros para modelar el

crecimiento de arbolesLas mallas geometricas son poderosas herramientas que modelan la realidad para per-

mitir resolver numericamente problemas de difıcil resolucion analıtica. Las mallas de su-perficie representan la superficie de un objeto como un conjunto de polıgonos contiguos.Uno de los campos en que se utilizan las mallas es el modelamiento de ecosistemas deorganismos vegetales. Un problema concreto que ha resultado interesante abordar es elcrecimiento de arboles, especıficamente de la corteza de su tronco, provocado por la con-centracion de una hormona de crecimiento en cada punto de su superficie.

El presente trabajo de tıtulo tuvo por objetivo desarrollar una herramienta para vi-sualizar y modificar mallas de cuadrilateros, que modelen la superficie del tronco de unarbol. Se enmarco dentro de un proyecto en el que dos alumnos habıan llevado a cabo sutrabajo de tıtulo, por lo que el desarrollo consistio en extender la aplicacion existente, queutilizaba mallas de triangulos, para que utilizara tambien mallas de cuadrilateros.

El primer obstaculo que se enfrento fue lograr un cabal entendimiento de la aplicaciondel legado. Un aspecto que ayudo a lograr este entendimiento fue el uso del paradigma dela Programacion Orientada a Objetos. Superado esto, el trabajo se dividio en dos campos:diseno e implementacion. En el primer ambito, se crearon jerarquıas de clases que mo-delaran la incorporacion de caras cuadrilateras. Ademas, se utilizaron patrones de disenopara permitir la creacion limpia de los algoritmos que modifican las mallas (deforman,refinan, desrefinan y mejoran), dependientes del tipo de caras que componen la malla.

En el ambito de la implementacion, se adaptaron los algoritmos existentes, o bien secrearon nuevos, para la generacion, guardado y deformacion de las mallas de cuadrilateros.En particular, se implementaron metodos para convertir mallas de triangulos en ma-llas de cuadrilateros y viceversa. Estos metodos permiten refinar y desrefinar mallas decuadrilateros, convirtiendo las caras en triangulos, aplicando luego los algoritmos paramallas de triangulos y aplicando otra conversion para tener una malla de cuadrilateros.

Como resultado, el generador de mallas desarrollado permite generar mallas de triangu-los y cuadrilateros, dejando la puerta abierta a futuros trabajos que implementen masalgoritmos para poder obtener un mayor provecho de la aplicacion. El diseno llevado acabo otorga gran facilidad para la incorporacion de estos nuevos algoritmos.

i

Agradecimientos

Agradezco el apoyo prestado por la profesora guıa, Sra. Nancy Hitschfeld, durante eldesarrollo de esta memoria. Su excelente disposicion para atender mis dudas genero intere-santes discusiones que ayudaron a mejorar la calidad de este trabajo y, al mismo tiempo,propicio un ambiente grato para este desarrollo.

Tambien debo mencionar mi agradecimiento a la Comision Nacional de InvestigacionCientıfica y Tecnologica, CONICYT, por el financiamiento de este trabajo, a traves delproyecto Fondecyt 1061227.

Del mismo modo, no puedo dejar de agradecer a las personas importantes dentro demi vida: mi familia y mis amigos del colegio y la universidad. En particular, a Francisco,mi mama, Anita y Camilın.

ii

Tabla de Contenidos

Agradecimientos II

1. Introduccion 11.1. Antecedentes generales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2. Motivacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3. Objetivo general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4. Objetivos especıficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5. Contenido de la memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2. Antecedentes 42.1. Marco teorico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.1.1. Precision en computacion geometrica . . . . . . . . . . . . . . . . . 52.1.2. Generacion de mallas geometricas . . . . . . . . . . . . . . . . . . . 8

2.2. Aplicacion del legado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.2.1. Metricas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.2.2. Funcionalidades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.2.3. Diseno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.2.4. Representacion de la malla . . . . . . . . . . . . . . . . . . . . . . . 152.2.5. Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3. Diseno 173.1. Rediseno asociado a la incorporacion de mallas de cuadrilateros . . . . . . 173.2. Rediseno de la clase Malla . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.3. Discusion sobre la incorporacion de nuevos algoritmos . . . . . . . . . . . . 22

3.3.1. Eliminacion de un nodo . . . . . . . . . . . . . . . . . . . . . . . . 223.3.2. Colapso de una region en un nodo . . . . . . . . . . . . . . . . . . . 253.3.3. Verificacion de inconsistencias . . . . . . . . . . . . . . . . . . . . . 303.3.4. Desrefinamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.3.5. Conversion de una malla de triangulos en malla de cuadrilateros . . 323.3.6. Conversion de una malla de cuadrilateros en malla de triangulos . . 33

3.4. Evaluacion del rediseno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4. Implementacion 374.1. Generacion de malla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374.2. Carga de malla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374.3. Guardado de malla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

iii

4.4. Correccion de errores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

5. Ejemplos 415.1. Conversion de malla de triangulos en malla de cuadrilateros . . . . . . . . 415.2. Conversion de malla de cuadrilateros en malla de triangulos . . . . . . . . 435.3. Algoritmo de colapso de una region . . . . . . . . . . . . . . . . . . . . . . 435.4. Conversion de malla de cuadrilateros en malla de triangulos . . . . . . . . 46

6. Conclusiones 49

Apendices 52A . Formatos de archivos de entrada y salida . . . . . . . . . . . . . . . . . . . 52B . Patrones utilizados o analizados en el desarrollo . . . . . . . . . . . . . . . 57

B .1. Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57B .2. Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58B .3. Abstract Factory . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58B .4. Bridge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59B .5. Prototype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

C . Metricas de la aplicacion del legado . . . . . . . . . . . . . . . . . . . . . . 60D . Metricas de la aplicacion del final . . . . . . . . . . . . . . . . . . . . . . . 62

iv

Indice de figuras

2.1. Malla que cumple con el criterio de Delaunay . . . . . . . . . . . . . . . . 92.2. Empaquetamiento con cırculos . . . . . . . . . . . . . . . . . . . . . . . . . 92.3. Algoritmo Paving . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.4. Malla triangular generada a partir de una medula . . . . . . . . . . . . . . 122.5. Diagrama de clases de la aplicacion del legado . . . . . . . . . . . . . . . . 14

3.1. Diagrama de clases para la creacion de algoritmos de desplazamiento . . . 203.2. VertexDeletion para caras triangulares . . . . . . . . . . . . . . . . . . . . 223.3. Generalizacion VertexDeletion para cuadrilateros . . . . . . . . . . . . . . 233.4. Problema al generalizar VertexDeletion para cuadrilateros . . . . . . . . . 233.5. Inconsistencia al generar malla de cuadrilateros: hay arcos colineales . . . . 243.6. Problema al desplazar nodo: una cara es concava y la otra convexa . . . . . 243.7. Problema al desplazar nodo: Caras dejan de ser coplanares . . . . . . . . . 253.8. Desplazamiento del nodo n1 hacia n . . . . . . . . . . . . . . . . . . . . . . 263.9. Algoritmo de colapso de una region de triangulos . . . . . . . . . . . . . . 263.10. Algoritmo de colapso de una region de cuadrilateros . . . . . . . . . . . . . 273.11. Aparicion de caras concavas al colapsar region . . . . . . . . . . . . . . . . 283.12. Flipping de arcos para mejorar calidad de la malla . . . . . . . . . . . . . . 283.13. Cuadrangulacion de una cara triangular . . . . . . . . . . . . . . . . . . . 32

4.1. Generacion de caras cuadrilateras a partir de una medula . . . . . . . . . . 384.2. Malla de seis caras triangulares . . . . . . . . . . . . . . . . . . . . . . . . 40

5.1. Malla de entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415.2. Malla de salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425.3. Malla de entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435.4. Malla de salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445.5. Malla de salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455.6. Malla de entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465.7. Malla luego de colapsar regiones repetidamente . . . . . . . . . . . . . . . 475.8. Malla luego de algoritmo de refinamiento . . . . . . . . . . . . . . . . . . . 48

6.1. Malla que se representara en distintos formatos . . . . . . . . . . . . . . . 526.2. Patron Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576.3. Patron Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586.4. Patron Abstract Factory . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586.5. Patron Bridge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

v

6.6. Patron Prototype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

vi

Capıtulo 1

Introduccion

1.1. Antecedentes generales

La Computacion Grafica abarca no solo desplegar figuras en la pantalla, sino queesas figuras sean el resultado del modelado de un problema real. Es ası como una apli-cacion comun es tratar geometrica y numericamente un problema de compleja resolucionanalıtica. Para ello se requieren poderosas herramientas que permitan representar la rea-lidad lo mas fielmente posible, con las restricciones de factibilidad y costo computacionalexistentes.

Una de las aplicaciones de la Geometrıa Computacional es el modelamiento de eco-sistemas de organismos vegetales. En particular, el modelamiento del crecimiento de unarbol es un problema que se ha abordado utilizando esta disciplina. Existen trabajos an-teriores [5, 10] en que, motivados por este problema, se construyo una aplicacion que dadacomo entrada una malla geometrica triangular que representa la superficie del tronco deun arbol, modela su evolucion en el tiempo.

Por otra parte, las mallas de cuadrilateros estan siendo cada vez mas comunes enaplicaciones tales como grafica de juegos, la industria del cine y visualizaciones medicas ycientıficas. En el caso particular de los arboles, sus celulas tienen forma de cuadrilateros,por lo que estos polıgonos son mas naturales para representar las celulas de la superficiede los arboles y modelar su crecimiento.

Resulta entonces interesante comparar los resultados obtenidos utilizando una mallatriangular y de cuadrilateros, en este caso de estudio.

1.2. Motivacion

Existe un grupo de profesionales de las areas de Matematica y Ciencias de la Com-putacion que se encuentra modelando el crecimiento de arboles. En particular, ha estudia-do el crecimiento radial de arboles conıferos (ejemplos de este tipo de arboles son el cipres

1

y el pino) como resultado de la dinamica de una de sus capas denominada cambium. Estacapa se ubica bajo la corteza del arbol y el crecimiento y division de sus celulas provocael crecimiento del arbol. Dentro de los factores que determinan el patron de crecimientode los arboles, se ha detectado la influencia de una hormona de crecimiento, lo que hallevado a modelar la tasa de crecimiento de una zona del arbol como la concentracion detal hormona en esa zona.

Esta memoria apoya el trabajo de ese grupo de profesionales y aborda el problemade modelar computacionalmente el crecimiento de un arbol, en particular de la superficiecilındrica de su tronco, mediante una malla de cuadrilateros. Este modelamiento buscarepresentar la mayor cantidad de propiedades observadas en la naturaleza al crecer unarbol. Un ejemplo de esto es la competicion por espacio de sus celulas, que lleva a ladesaparicion de algunas de ellas, lo que se representa con el proceso de desrefinamientode la malla, en el que se eliminan caras, aumentando el area de las caras vecinas a laeliminada. Del mismo modo, el crecimiento del arbol se modela como el desplazamientode cada uno de sus puntos, en direccion saliente al tronco. Por lo tanto, cada punto de lamalla sufre distintos desplazamientos. La concentracion de la hormona de crecimiento enun punto es usada para estimar el desplazamiento de tal punto. Es posible que al deformarla malla esta no quede consistente. Por ejemplo, pueden voltearse caras o intersectarse.Por lo tanto, surge la necesidad de abordar estrategias que se preocupen de mantener laconsistencia de la malla al deformarla.

Ademas, se requiere que la implementacion de la herramienta se adhiera al paradigmade la Programacion Orientada a Objetos, con el fin de apoyar la extensibilidad y claridadde la aplicacion a desarrollar, caracterısticas muy valiosas considerando que probable-mente otras personas continuaran trabajando en este sistema.

1.3. Objetivo general

El objetivo general de esta memoria es implementar una herramienta para visualizar,desplazar y trabajar (refinar/desrefinar, suavizar) mallas geometricas de cuadrilateros. Sereutilizara el diseno de las clases y la implementacion de la interfaz grafica de la aplicaciondel legado [10], en la medida de lo posible. Se redisenaran clases y parte de la interfaz quenecesiten perfeccionarse y se crearan las clases necesarias para extender las funcionalida-des de la aplicacion del legado a mallas de cuadrilateros.

1.4. Objetivos especıficos

Adaptar, disenar e implementar algoritmos para generar, cargar, visualizar y guardarmallas de cuadrilateros.

Revisar y mejorar el diseno actual. Por ejemplo, la representacion de la malla es una

2

clase que posee metodos que no corresponden al alcance de la malla y que puedenreimplementarse en otra clase.

Incorporar algoritmos de transformacion para mallas de cuadrilateros: deformacion,refinamiento y desrefinamiento.

Revisar y mejorar la robustez de la implementacion actual.

1.5. Contenido de la memoria

Este informe se estructura en los siguientes capıtulos:

Introduccion: Introduccion al problema.

Antecedentes: Antecedentes que facilitan el entendimiento del problema y su solucion.

Diseno: Discusion sobre las decisiones de diseno tomadas.

Implementacion: Detalles sobre la implementacion de algunas de las funcionalidades.

Ejemplos: Ejemplos de uso del sistema.

Conclusiones: Conclusiones respecto al trabajo realizado.

3

Capıtulo 2

Antecedentes

En este capıtulo se entregaran antecedentes para facilitar el entendimiento del trabajorealizado. Se explicaran algunos de los temas estudiados en la revision bibliografica queprecedio este trabajo y se revisara la aplicacion del legado, tanto en funcionalidades comoaspectos de diseno.

2.1. Marco teorico

En la generacion de mallas en 2D (dos dimensiones), los dos enfoques mas comunesson utilizar triangulos o cuadrilateros.

Los triangulos son los polıgonos mas simples y poseen importantes propiedades (porejemplo, sobre el tamano de sus lados, medianas y puntos notables) y relaciones con cir-cunferencias (inscritas, circunscritas). Esta simplicidad y, a la vez, riqueza, hacen que lostriangulos hayan sido la figura geometrica natural para crear mallas geometricas que dis-cretizan figuras reales.

Por otra parte, los cuadrilateros son figuras mas complejas que los triangulos y, adiferencia de estos, pueden no estar completamente contenidos en un plano (utilizando ladefinicion generica de cuadrilateros, que no exige que sean polıgonos). Ademas, su repre-sentacion es mas compleja, pues dependiendo del orden en que se unen los cuatro puntos,se genera un cuadrilatero valido o bien polıgonos no simples (con arcos cruzados).

Sin embargo, el uso de mallas compuestas por cuadrilateros es un enfoque que ha gana-do adeptos, pues se considera que estas mallas son mas precisas y flexibles. Una dificultadde abordar este enfoque es que no existe abundante literatura al respecto como en el casode las mallas de triangulos.

En particular, enfocandose en el problema a tratar en esta memoria, se cree que lasmallas de cuadrilateros podrıan representar mejor la estructura de la corteza de un arbol,al ser la forma de las celulas mas similar a esta figura geometrica, lo que permitirıa simularla distribucion de la hormona de crecimiento en el arbol de manera mas natural.

4

Existe un trade-off entre los metodos de generacion automatica de mallas geometricasde cuadrilateros y los que requieren intervencion manual. Los primeros entregan una mallade menor calidad (errores en los bordes de la malla y mayor numero de nodos irregulares),por lo que a veces se descompone manualmente la geometrıa en regiones antes de aplicarlos metodos automaticos, lo que evidentemente conlleva mayor trabajo. Existen tambienenfoques intermedios que intentan aprovechar lo mejor de ambas alternativas: paving [2],que construye progresivamente la malla insertando filas de cuadrilateros desde el contornodel objeto hacia el interior.

Por otra parte, independientemente de la figura geometrica usada para generar lamalla, existen propiedades que se deben garantizar, en particular cuando se evaluaranmodelos matematicos en la malla generada, como en el caso de esta memoria. Algunas delas consideraciones necesarias son [4, 9]:

Representar el dominio de la manera mas exacta posible, acotando el error. Es-to es particularmente importante en los bordes, pues las aplicaciones cientıficas oingenieriles suelen ser sensibles a cambios en ellos.

Considerar las restricciones impuestas por los metodos numericos usados, principal-mente para acelerar la convergencia de estos. Las restricciones son:

• Ser conforme.

• Satisfacer requisitos de densidad de puntos, usando la menor cantidad de puntosposibles. (Metodos de refinamiento).

• Satisfacer criterios de calidad medidos en funcion de angulos, aspecto de radio,altura y area, entre otros.

• Evitar angulos muy pequenos. (Metodos para mejorar la calidad).

A continuacion se desarrollaran alguno de estos puntos.

2.1.1. Precision en computacion geometrica

Los computadores tienen recursos limitados y, por lo tanto, no pueden representar unconjunto infinito de numeros, como los enteros o los reales, sino que utilizan representa-ciones aproximadas de estos. En el caso de los enteros, se representa solo un rango de ellos.En el caso de los reales, ademas de no representar los valores fuera de un cierto intervalo,tampoco se representan todos los valores de ese intervalo, pues dentro de cualquier inter-valo no vacıo de reales hay infinitos valores y obviamente no pueden representarse todosellos. En adelante se limitara la discusion a la representacion de reales, tambien llamadarepresentacion en punto flotante, pues la Computacion Geometrica utiliza aritmetica realy no entera.

5

El conjunto de numeros de punto flotante F(β, p, emin, emax), donde β es la base, p esla mantiza, emin es el mınimo exponente y emax el maximo, se define como [8]:

F = {x = s ·p−1∑k=0

dkβ−k · βe/s ∈ {1,−1}, dk ∈ Z ∩ [0, β),

e ∈ Z ∩ [emin, emax],∑

|dk| > 0 ⇒ d0 > 0}

La expresion anterior corresponde a la representacion normalizada, es decir, d0 > 0a menos que x = 0. Esta convencion se ocupa para disminuir los errores cometidos alrealizar operaciones. En los sistemas computacionales, se trabaja con numeros binarios(β = 2) normalizados, por lo que d0 es siempre 1, ası que no es necesario almacenarlo.

Para aproximar numeros reales en este conjunto F, se implementa la funcion fl : R →F, que a cada x en R le asigna el numero en F mas cercano a x y de no ser unico, le asignaaquel con ultimo dıgito distinto de cero par.

El error relativo de aproximar x por fl(x) esta acotado superiormente por εm, unaexpresion constante con respecto a x y dependiente solo de la base β y de la mantiza pcaracterısticas del conjunto F. A esta expresion se le llama epsilon maquina.

Los numeros representables en un sistema de punto flotante no se distribuyen ho-mogeneamente, sino que la distancia entre ellos va aumentando con el exponente e uti-lizado; por lo tanto, aumenta el error absoluto que se puede cometer, pero el error relativosiempre esta acotado por epsilon maquina.

Para implementar una funcion real f en un sistema de numeros flotantes, se construyeuna funcion analoga f que va desde F a F y se dice que implementa bien a la original sicorresponde a la mejor aproximacion posible en F, es decir, si:

f(x) = fl(f(x))

La mayorıa de las funciones no son bien implementadas en los sistemas numericos. Solose garantiza que un numero pequeno de ellas lo sea, como las operaciones elementales bi-narias (suma, resta, multiplicacion y division) y algunas unarias (como la raız cuadrada).Las demas funciones que se derivan de ellas no siempre estan bien implementadas y, por lotanto, los errores relativos en los calculos pueden ser mayores a epsilon maquina. Ademas,al realizar sucesivas operaciones, aunque cada una de ellas por separado este bien imple-mentada, se va acumulando el error y aumenta la cota del error. Las operaciones que serealizan en un sistema de numeros flotantes se dice que usan aritmetica imprecisa.

Un caso que se ha estudiado particularmente es el error numerico en una suma determinos: S =

∑i ai. La cota al error cometido que se ha encontrado es directamente

proporcional a epsilon maquina, al numero de terminos sumados y a un factor de ampli-ficacion A:

6

A =

∑ai>0 ai +

∑ai<0−ai∑

ai>0 ai −∑

ai<0−ai

Si∑

ai>0 ai ≈∑

ai<0−ai, entonces A → +∞, lo que se conoce como la amplificacionde errores producida por diferencias de numeros cercanos.

Lo anterior no significa que necesariamente los errores crezcan al hacer diferencia denumeros cercanos, pues se trata de una cota superior, pero empıricamente se han ob-servado casos en que se alcanzan valores cercanos a la cota, por lo que es altamenterecomendable evitar usar expresiones donde aparezcan diferencias de numeros cercanos.Por ejemplo, muchas de esas expresiones pueden reescribirse para evitar esta situacion:

√n + 1−

√n = 1√

n+1+√

n

1n− 1

n+1= 1

n(n+1)

Al no acotar el error acumulado puede tenerse que el valor absoluto del error de apro-ximacion cometido sea mayor al valor absoluto de la expresion, es decir, “que el error secoma la expresion”.

El no controlar los errores numericos cometidos al implementar algoritmos geometri-cos, puede llevar a programas que se caen, se quedan en ciclos infinitos, o simplementeentregan resultados erroneos.

La parte mas crıtica en la implementacion son las condiciones, pues ellas determinan elflujo de control del programa. La mayorıa de ellas involucra desigualdades, las que puedenreformularse como preguntas sobre el signo de una expresion. El enfoque mas comun esutilizar un valor epsilon para suponer que un numero es suficientemente cercano a cero, sies menor a epsilon, y por lo tanto considerarlo como cero, lo que puede ser errado pues en-tre cero y epsilon hay valores representables en la aritmetica imprecisa cuya aproximaciona cero es incorrecta. El principal problema de este enfoque es que, para simplificar, se eligepor ensayo y error el valor de epsilon y se le considera constante en todos los calculos, sintomar en cuenta el tamano de los operandos involucrados.

Un mejor enfoque es realizar calculos exactos, es decir, procurar que todas las deci-siones hechas por el algoritmo sean correctas. Para ello, no es necesario que todos loscalculos se realicen con aritmetica exacta, sino que basta con que los errores producidosno alteren las decisiones del algoritmo. La tecnica de floating point filter apunta a estomismo y consiste en identificar aquellos casos en que el error podrıa llevar a una maladecision y, solo en esos casos, reevaluar la expresion con alguna tecnica que permita asegu-rar que la decision es correcta; por ejemplo, esa tecnica puede ser usar aritmetica exacta.Esto se justifica porque realizar aritmetica exacta es caro y en ocasiones ni siquiera esposible hacerlo, por ejemplo, no es posible representar exactamente numeros irracionales

7

en ningun sistema computacional, pues tienen infinitas cifras.

Por ejemplo, la tecnica de floating point filter se puede usar para determinar si un con-junto de puntos esta dentro de una circunferencia de centro (x0, y0) y radio r. Para ello hayque revisar si cada punto (x, y) cumple con la condicion r2−(x−x0)

2+(y−y0)2 ≥ 0. Para

los puntos que no se encuentran “cerca” del borde (tomando como escala el posible errorcometido), no se requiere usar aritmetica exacta. En cambio los puntos cercanos al bordede la circunferencia se pueden calcular con aritmetica exacta, pues utilizando aritmeticainexacta podrıan clasificarse, incorrectamente, como dentro o fuera de la circunferencia.

Al implementar un algoritmo geometrico hay que tratar con especial cuidado los casosdegenerados. Los casos degenerados corresponden a una configuracion lımite de un prob-lema geometrico tal que no es una entrada que los algoritmos que resuelven el problemaesten preparados para recibir. En ese sentido, constituyen excepciones del algoritmo, puesno se les puede aplicar el mismo procesamiento que para el resto de las entradas. Desdeel punto de vista del calculo, esto se traduce en que cuando el algoritmo quiere testearel signo de una expresion, se encuentra con que la expresion vale cero y hay que definirque hacer en ese caso, pues se esperaba clasificar la expresion como positiva o negativa.Los casos degenerados obligan a hacer implementaciones mas complejas para tratar estasexcepciones. Otro enfoque es convertir un caso degenerado en uno no degenerado, dandoleun signo a las expresiones que son cero.

Otro problema existente es cuando se utilizan epsilons y se puede clasificar como uncaso degenerado uno que no lo es (un valor muy cercano a cero, pero distinto de cero).

Un ejemplo de caso degenerado es cuando se quiere trabajar con el triangulo formadopor tres rectas no paralelas, pero las tres rectas se intersectan en un mismo punto. Aldeterminar la distancia entre los vertices del triangulo, se espera que el valor sea positivo,pero se obtiene un valor cero.

2.1.2. Generacion de mallas geometricas

Todo polıgono puede ser particionado en triangulos mediante la sucesiva adicion dediagonales (segmentos que unen dos vertices no consecutivos) [6]. Este simple proceso des-cribe un algoritmo de generacion de mallas triangulares en 2D. Sin embargo, el algoritmoampliamente usado es la triangulacion de Delaunay, que asegura un grado de calidad dela malla al maximizar el mınimo angulo entre todas las posibles triangulaciones de unpolıgono. Esto lo logra exigiendo que cada triangulo cumpla el criterio de Delaunay, estoes, que su circuncırculo (el cırculo circunscrito en el triangulo) sea vacıo, es decir, sinvertices en su interior, como se muestra en el ejemplo de la figura 2.1. El mismo principiose aplica para triangular superficies en 3D.

En el caso de mallas de cuadrilateros, pueden ser generadas triangulando el dominioy luego dividiendo cada triangulo en tres cuadrilateros. Se puede incluso minimizar el

8

Figura 2.1: Malla que cumple con el criterio de Delaunay

numero de cuadrilateros generados si el dominio es convexo. El problema de este enfoquees que puede generar mallas de mala calidad.

Otro enfoque es el presentado en [1], que apunta a “empaquetar cırculos”, esto es,llenar el dominio con cırculos de modo que el espacio entre ellos este rodeado de tres ocuatro cırculos tangentes y luego unir los centros de los cırculos formando cuadrilateros,como se muestra en la figura 2.2. Este algoritmo busca garantizar la calidad de la mallaformada y acotar el numero de cuadrilateros usados.

Figura 2.2: Empaquetamiento con cırculos

Un algoritmo que ha ganado adeptos es el de Paving [2], que permite generar ma-llas bien formadas (es decir, los elementos son cercanos a cuadrados, perpendiculares a

9

los bordes, etcetera) y geometricamente satisfactorias (es decir, los contornos de la mallatienden a seguir los contornos geometricos de los bordes).

El algoritmo consiste en iterativamente disponer filas de elementos desde el borde dela region hacia el interior, tal como se muestra en la figura 2.3. Cuando las filas se super-ponen o coinciden, cuidadosamente se conectan para formar una malla de cuadrilaterosvalida.

Figura 2.3: Algoritmo Paving

Este algoritmo es un aporte con respecto a otros, pues logra generar una malla au-tomaticamente, sin los costos comunes asociados a la automatizacion: mala calidad (faltade sensibilidad en los bordes y gran presencia de nodos que se conectan con un numerode nodos distinto a cuatro).

2.2. Aplicacion del legado

La aplicacion del legado corresponde al software desarrollado en dos memorias de tıtu-lo anteriores [5, 10]. A continuacion se describira el estado de la aplicacion al inicio deldesarrollo de este trabajo de tıtulo.

2.2.1. Metricas

Utilizando la herramienta Understand C++ 1 se obtuvieron las metricas de la apli-cacion del legado que se muestran a continuacion:

1http://scitools.com/products/understand/cpp/product.php

10

Metrica Valor

Nro. de clases 77Nro. de archivos 132Nro. de lıneas 12991Nro. de lıneas en blanco 1807Nro. de lıneas de codigo 9245Nro. de lıneas de comentarios 1375Radio Comentarios/Codigo 0.15

Estos valores permiten cuantificar el tamano de la aplicacion del legado, desarrolladaen un proceso iterativo por dos memoristas y explica que al principio la velocidad deavance en el desarrollo de este trabajo de tıtulo fuera menor a la estimada y que luegohaya aumentando, conforme aumentaba el entendimiento de la aplicacion del legado.

2.2.2. Funcionalidades

La aplicacion trabaja con mallas de triangulos, pero tiene un desarrollo incipiente enmallas de cuadrilateros.

En terminos generales, permite crear mallas iniciales simples, cargar mallas desde dis-tintos formatos de entrada y guardarlas tambien en varios formatos de salida.

Permite la visualizacion grafica de mallas y modificar una malla deformandola, re-finandola, desrefinandola o mejorandola. Ademas, entrega informacion sobre la composi-cion de la malla.

De forma mas detallada, las funcionalidades de la aplicacion son:

Crear malla: Se pueden crear mallas a partir de una medula (una curva generatriz dela malla que modela el centro del tronco del arbol) y crear mallas cilındricas. En elcaso de la medula, el usuario especifica el nombre del archivo donde se encuentranlas coordenadas de la medula. El cilindro, por su parte, corresponde al caso en quela medula esta descrita por una lınea vertical, por lo tanto, en vez de ingresarselas coordenadas de la medula, se ingresa la altura del cilindro. En ambos casosel algoritmo consiste en generar anillos horizontales alrededor de la medula. Cadaanillo se compone de un numero constante de nodos. Al unir los nodos, se genera lamalla. El usuario ingresa el radio, numero de anillos y numero de puntos por anilloque desea generar.

Las mallas cilındricas pueden estar compuestas o bien de triangulos o bien decuadrilateros, segun lo decida el usuario. Las mallas generadas a partir de una medu-la solo son triangulares.

Cargar malla: Se pueden cargar mallas en distintos formatos de entrada: Comsol, Mat-lab, nxyzu y Geomview (los formatos se explican en el Apendice). Cada formatotiene su propio algoritmo para cargar la malla, pero a grandes rasgos todos ellos

11

Figura 2.4: Malla triangular generada a partir de una medula

leen las coordenadas de los nodos de la malla, leen o deducen el orden en que losnodos forman las caras, crean los nodos y caras correspondientes y ademas los arcosde las caras. Del mismo modo leen o calculan las normales de los puntos y calcu-lan las normales de las caras. Una vez cargada la malla, ya no se distingue desdeque formato fue cargada, o si fue creada directamente en la aplicacion. Esto permitemodelar el crecimiento de arboles de geometrıa compleja.

Visualizar malla: Al crear o cargar una malla, esta es dibujada por la aplicacion. Sepuede elegir si se desean ver o no las caras y/o arcos de la malla. Ademas, se puedemover la camara de forma de acercar, alejar y rotar la malla.

Guardar mallas: Las mallas pueden ser guardadas en distintos formatos de salida: Com-sol, nxyzu, Off y Debug. Este ultimo formato es de uso interno y se utiliza para depu-rar la aplicacion, pues consiste en un recorrido exhaustivo por toda la informacionde la malla.

Deformar malla: La malla puede ser deformada. La deformacion consiste en el desplaza-miento de cada nodo de la malla segun su concentracion y en direccion normal alnodo. El usuario indica el porcentaje de la concentracion que se movera cada nodoen un paso y el numero de pasos que se movera la malla. Los nodos se desplazan unpaso por unidad de tiempo y se puede cambiar la velocidad de la animacion resul-tante. El usuario tambien ingresa el algoritmo de verificacion que desea aplicar, esdecir, como se trataran las posibles inconsistencias que se produciran al desplazar losnodos de la malla. Una de las opciones posibles es no realizar ninguna verificacion,es decir, deformar la malla aunque esta quede inconsistente.

Refinar malla: Se puede refinar la malla, es decir, aumentar el numero de caras de lamalla disminuyendo el area de las caras originales. El usuario elige el algoritmo derefinamiento y el criterio para seguir aplicando el algoritmo.

12

Desrefinar malla: Se puede desrefinar la malla, es decir, disminuir el numero de carasde la malla aumentando el area de las caras sobrevivientes. El usuario elige el criteriopara seguir aplicando el algoritmo de desrefinamiento.

Mejorar malla: Se puede aplicar un algoritmo de mejoramiento de la calidad de la malla.El algoritmo implementado es el que usa el criterio de Delaunay.

Ver informacion malla: Se puede desplegar un cuadro con informacion sobre la com-posicion de la malla (numero de caras, area promedio de las caras, etc.). Esta in-formacion es de suma importancia para escoger los parametros adecuados al aplicaralgoritmos de refinamiento y desrefinamiento.

2.2.3. Diseno

La aplicacion del legado fue disenada siguiendo el paradigma de la ProgramacionOrientada a Objetos. En la figura 2.5 se muestra el diagrama de clases, en donde se apre-cia el uso de patrones de diseno y la separacion entre la capa de presentacion y la logicade la aplicacion.

Los patrones de diseno entregan buenas soluciones a problemas recurrentes en el disenode un sistema, beneficiando particularmente la reusabilidad del sistema. A continuacionse describen los patrones utilizados en la aplicacion del legado.

Command: En la aplicacion, este patron es utilizado para encapsular los requerimientosque el usuario realiza a traves de la interfaz grafica, de modo de separarlos de lacapa logica que se encarga de ejecutarlos. Las clases que cumplen el rol de comandoson Generar, Guardar, Refinar, Desrefinar, Mejorar, Deformar e Informar.

Strategy: Este patron es utilizado para encapsular una familia de algoritmos de formaque sea facil intercambiarlos y agregar nuevos algoritmos. En la aplicacion, para cadacomando, salvo Informar, hay una familia de algoritmos encargada de satisfacer elrequerimiento asociado al comando.

Este patron es muy util en una aplicacion como esta, donde distintas personas hantrabajado en distintas iteraciones, pues la incorporacion de un nuevo algoritmo selimita a la creacion de la clase que lo implementa y a agregar la opcion en la interfaz.

Se considera que hay dos importantes aspectos mejorables del diseno. El primero es laclase Cara, que representa una cara de cualquier numero de lados, pero que tiene metodosque solo son validos para triangulos. El segundo es la clase Malla, que tiene mas de 50metodos publicos, sin contar constructores, setters ni getters. Esto se debe a que la mallaes la unica clase que tiene toda la informacion necesaria para realizar la mayorıa de loscalculos necesarios, situacion que se explicara en mas detalle en la proxima seccion.

La gran cantidad de metodos de la clase Malla es un problema, pues afecta su man-tenibilidad y ademas es conceptualmente errado que esa clase deba hacerse cargo decomportamientos que no le corresponden, como determinar el area de una cara.

13

Figura 2.5: Diagrama de clases de la aplicacion del legado

14

2.2.4. Representacion de la malla

A continuacion se explica la representacion de la clase Malla, la mas importante delsistema y, a su vez, la representacion de las clases que la componen.

Malla: Basicamente, se representa por tres contenedores: de objetos nodos, arcos y caras.

Nodo: Se representa mediante un punto, un vector normal y una concentracion. Porrazones de eficiencia, mantiene ademas vectores de ındices de los arcos y caras delos que forma parte. Los ındices, tanto en esta clase como en las siguientes, son conrespecto a los contenedores que almacena la malla.

Arco: Se representa mediante ındices de los dos nodos que lo conforman y de las doscaras de las que forma parte.

Cara: Se representa mediante vectores de ındices de los nodos y arcos que la conforman.Ademas, almacena su numero de lados y color.

La aplicacion trabaja con clases contenedoras: Nodos, Arcos y Caras, que proveenmetodos para borrar, agregar y obtener elementos, entre otros metodos.

De lo anterior se deduce que solo la clase Malla tiene referencias a los nodos, arcos ycaras. Las otras clases almacenan ındices, pero no tienen acceso a los contenedores referen-ciados por los ındices. Por lo tanto, un arco no es capaz de calcular su largo, pues no conocela posicion de los nodos que lo forman, sino solo los ındices de los nodos. Esto hace quelas clases Nodo, Arco y Cara esten compuestas principalmente por constructores, settersy getters y que los comportamientos de estas clases esten implementados en la clase Malla.

2.2.5. Algoritmos

La aplicacion implementa una serie de algoritmos para modificar la malla. A conti-nuacion se explican.

Verificacion desplazamiento: Al deformar la malla, cada nodo se desplaza una dis-tancia proporcional a su concentracion, en la direccion de su normal. Estos despla-zamientos pueden producir colisiones, por lo que se implementan tres algoritmospara tratarlas: No Verificacion, Verificacion Local y Verificacion Nodos Vecinos. Elprimero de ellos no realiza ninguna verificacion, por lo que simplemente desplaza lamalla.

El algoritmo Verificacion Local recorre pares de caras vecinas (comparten un arco)coplanares y detecta si hay interseccion entre sus arcos y, de haberla, intenta corregiresta inconsistencia haciendo flipping de arcos.

El algoritmo Verificacion Nodos Vecinos recorre los nodos y para cada nodo, en-cuentra el polıgono formado por los arcos de las caras incidentes en el nodo, de forma

15

que el nodo queda en el centro del polıgono. Luego, construye un pseudocilindro enque la base inferior es el polıgono y la base superior esta formada por las posicionesfuturas de los vertices del polıgono (luego del desplazamiento), de forma tal quelas aristas verticales del cilindro son las trayectorias de los vertices. El algoritmodetermina si la trayectoria del nodo central colisiona con alguna de las paredes delcilindro, lo que provocarıa que una cara se volteara. Si es ası, corrige la trayectoriadel nodo central, haciendo que la direccion de la normal del nodo sea la suma de lasnormales de los vertices del polıgono. Si este proceso no corrige la inconsistencia,entonces borra el nodo central.

Refinamiento: Existen dos clases que implementan algoritmos de refinamiento: Lepp-Delaunay y DelaunayLongestEdgeBisection. En la primera de ellas se aplica el algo-ritmo LEPP-Delaunay [7] a cada cara que cumple con el criterio dado. El algorit-mo LEPP-Delaunay iterativamente encuentra el LEPP (Longest Edge PropagationPath) de la cara a refinar y realiza una insercion Delaunay en la arista terminal, esdecir, divide los dos triangulos unidos por la arista y hace flipping de arcos para quecumplan el criterio de Delaunay, en caso que fuera necesario.

En la segunda clase, DelaunayLongestEdgeBisection, en cada cara que cumple elcriterio, se divide por la mitad su arco mas largo, cambiando los arcos necesariospara que se cumpla el criterio de Delaunay antes y despues de la division.

Desrefinamiento: El algoritmo Desrefinamiento Edge Collapse recorre la malla buscan-do caras que cumplan el criterio para aplicar al algoritmo, por ejemplo, el area de lacara es mayor al maximo valor al que se quiere llegar. Luego detecta el menor arcode esa cara y lo colapsa en un nodo, eliminando las dos caras adyacentes a el.

Mejora: El algoritmo Mejora Delaunay recorre la malla buscando pares de triangulosvecinos que no cumplan el criterio de Delaunay (es decir, existen vertices al interiordel cırculo circunscrito en el). Luego reemplaza el arco comun de los triangulos porel otro posible, haciendo que ambos triangulos cumplan con el criterio (flipping dearcos).

16

Capıtulo 3

Diseno

En este capıtulo se analizaran las decisiones de diseno tomadas en el desarrollo deeste trabajo. Por ejemplo, se abordara el tema de la incorporacion de nuevos patrones dediseno a la aplicacion.

Los patrones de diseno son soluciones conocidas y validadas a problemas recurrentesal disenar un sistema. La aplicacion del legado utiliza dos de ellos: Command y Strategy,como se explico en la seccion 2.2.3. En este capıtulo, se analizara la incorporacion de dosnuevos patrones: Abstract Factory y Bridge 1. El primero de ellos provee una interfazpara la creacion de familias de objetos relacionados, sin especificar su clase concreta [3].En este caso, se desea utilizar para crear una fabrica de algoritmos validos para mallasde triangulos y una para mallas de cuadrilateros, de forma de que se pueda satisfacer,por ejemplo, el requerimiento del usuario de desplazar la malla, pidiendole a la fabrica unalgoritmo de desplazamiento, sin tener que lidiar con el problema de saber que algoritmode desplazamiento se puede aplicar, segun el tipo de malla con el que se esta trabajando.

El otro patron analizado fue Bridge. Este patron permite desacoplar una abstraccionde su implementacion, de forma que ambas puedan modificarse independientemente. Enparticular, se evaluo utilizar este patron para modelar la existencia y convivencia de dosjerarquıas: la de la malla, segun el tipo de caras que la componen, y la de los algoritmosque trabajan sobre la malla, donde se utiliza el patron Strategy.

3.1. Rediseno asociado a la incorporacion de mallas

de cuadrilateros

Para incorporar a la aplicacion mallas de cuadrilateros se hace necesario modificar laclase Cara. En la aplicacion del legado, esta clase esta representada por vectores de ındicesde nodos y de arcos y por un entero que indica el numero de lados de la cara.

El trabajar con vectores sin preocuparse de su largo, es decir, del numero de lados dela cara, hace que los metodos sean mas generales y por lo tanto mas reusables. Ademas, en

1Ir a Apendice B para ver los diagramas de clase

17

muchos casos acortan la extension del codigo. Sin embargo, es incorrecto conceptualmentetener las caras de cualquier numero de lados en una misma clase siendo que no tienensiempre el mismo comportamiento, lo que se evidencia en la implementacion del legadoen que hay metodos de la clase que solo son validos para triangulos.

La necesidad de crear una jerarquıa se hace mas clara aun al querer extender los al-goritmos de desplazamiento, refinamiento, desrefinamiento y mejoramiento a mallas decuadrilateros. Estos algoritmos son fuertemente dependientes de la forma de las caras dela malla y, por lo tanto, no es cierto que funcionen para caras de cualquier numero delados. Por ejemplo, el algoritmo de mejoramiento utiliza el criterio de Delaunay, que sebasa en propiedades geometricas de los triangulos.

Corresponde entonces crear una jerarquıa para la clase Cara donde ella es la clase basey las clases Triangulo y Cuadrilatero son derivadas, dejando ademas abierta la posibilidada la incorporacion de nuevas clases (caras con mas de cuatro lados).

El primer enfoque que se tomo para llevar a cabo este rediseno fue hacer que la claseCara fuera una clase abstracta que incluyera todos los metodos que representan el com-portamiento de una cara, independientemente de su numero de lados. Los metodos querepresentan el comportamiento especıfico de un triangulo o cuadrilatero, debıan estar ensu correspondiente clase derivada.

Este enfoque finalmente fue modificado pues algunos de los formatos desde los que secarga la malla soportan el uso de caras de mas de cuatro lados y los archivos de ejemplocon los que se trabaja incluyen esos casos. Se prefirio entonces no restringir la aplicaciony seguir permitiendo la visualizacion de este tipo de mallas, aunque no exista la imple-mentacion de los algoritmos para modificar esas mallas. Por lo tanto, se decidio que laclase Cara no serıa abstracta, sino que se crearıan instancias para representar caras demas de cuatro lados y que los algoritmos que modifican la malla y que son propios detriangulos o cuadrilateros trabajarıan con objetos de la clase derivada correspondiente, deforma de mantener un diseno correcto y consistente.

Del mismo modo, se hizo necesario crear una jerarquıa para la clase Malla, por lo quese crearon las clases MallaTriangulos y MallaCuadrilateros y se permitio igualmente tenerinstancias de la clase Malla original.

Recordemos que se desea hacer un diseno que permita trabajar con mallas de triangu-los y cuadrilateros lo mas transparentemente posible, de forma de asociar correctamentelos algoritmos validos a cada tipo de malla, sin tener que hacer chequeos de tipo. Tambiense considero importante facilitar la incorporacion de nuevos tipos de malla, por ejemplo,una malla mixta de triangulos y cuadrilateros.

Para lograr lo anterior, se decidio utilizar el patron Abstract Factory [3] para que laeleccion de los tipos de algoritmos a utilizar se realizara una sola vez, al crear la fabrica,y que luego el resto de la implementacion pudiera abstraerse del tipo de malla con la cual

18

se estaba trabajando. Con este enfoque, se crearıan dos fabricas, una para los algoritmosaplicables en mallas de triangulos y otra para los aplicables en mallas de cuadrilateros.Los productos serıan los algoritmos para desplazar, refinar, desrefinar y mejorar las mallas.

El problema que surgio es que para cada una de estas acciones que pueden realizarsesobre la malla, existe potencialmente una familia de algoritmos que las lleva a cabo, puesse esta usando el patron Strategy. Por lo tanto existen dos jerarquıas que deben convivir:la que refleja el tipo de malla en el que el algoritmo se aplica y la que refleja las distintasimplementaciones existentes para el algoritmo. Se evaluo utilizar el patron Bridge paradisenar esta situacion, pero se considero que no era aplicable porque la implementaciondel algoritmo depende del tipo de malla en que se usa.

La solucion llevada a cabo fue hacer una doble jerarquıa para cada tipo de algoritmo.Primero se divide segun el tipo de malla sobre el que se aplica el algoritmo y luego sehace la division segun las implementaciones. La opcion de hacer las jerarquıas en el ordeninverso, es decir, primero por implementacion y luego por tipo de malla, se descarto puesno todas las implementaciones existen para cada tipo de malla. En cambio, conceptual-mente pueden existir implementaciones para cada tipo generico de algoritmo, para cadatipo de malla.

Para incorporar el patron Abstract Factory se considero solo la primera jerarquıa decada tipo de algoritmo, pues el patron es aplicable si se pueden fabricar los mismos tiposde productos en cada fabrica. Como se dijo anteriormente, los productos no pueden serlas implementaciones especıficas de cada algoritmo, pues la fabrica de mallas de triangu-los no ofrecerıa los mismos productos (implementaciones) que la fabrica de mallas decuadrilateros.

Finalmente, el diseno adoptado se muestra en la figura 3.1, donde se observa que cadametodo de la fabrica recibe un identificador del tipo de implementacion que se elegira,segun la segunda jerarquıa creada para cada algoritmo. Se puede ver un ejemplo del meto-do para crear un algoritmo de desplazamiento en la fabrica de mallas de triangulos y enla de cuadrilateros, en Algorithm 1 y Algorithm 2, respectivamente.

El crear estas jerarquıas implico trabajar en varios ambitos. El primero fue revisartodos los metodos de las clases a especificar (Cara y Malla) e identificar los metodos queimplementaban comportamientos propios de esas clases genericas, modificando sus imple-mentaciones en los casos que fue necesario, como cuando habıa implementaciones validassolo para triangulos, pero que eran generalizables. Ademas, se dejaron en las subclases losmetodos especıficos, tanto los existentes como los que hubo que implementar para carasy mallas de cuadrilateros.

Otro ambito a abordar fue el detectar la creacion de objetos de las clases bases ycambiarlos por la creacion de objetos de las subclases, segun correspondiera.

19

Figura 3.1: Diagrama de clases para la creacion de algoritmos de desplazamiento

Algorithm 1 Creacion de algoritmo desplazamiento en FabricaAlgMallaTriangulos

1: AlgDesplazamiento *crearAlgoritmoDesplazamiento(int tipo) {2: AlgDesplazamientoMallaTriangulos *algoritmo = NULL3: if tipo = 1 then4: algoritmo = new NoVerificacion()5: else if tipo = 2 then6: algoritmo = new VerificacionLocal()7: else if tipo = 3 then8: algoritmo = new VerificacionNodosVecinos()9: end if

10: return algoritmo11: }

20

Algorithm 2 Creacion de algoritmo desplazamiento en FabricaAlgMallaCuadrilateros

1: AlgDesplazamiento *crearAlgoritmoDesplazamiento(int tipo) {2: AlgDesplazamientoMallaCuadrilateros *algoritmo = NULL3: if tipo = 1 then4: algoritmo = new VerificacionNodosVecinosColapsoRegion()5: end if6: return algoritmo7: }

3.2. Rediseno de la clase Malla

Esta clase necesitaba ser redisenada pues poseıa mas de 50 metodos publicos, sin contarlos constructores, getters y setters. Esta gran cantidad de metodos le quitaba mantenibi-lidad a esta, la principal clase del sistema.

Esta gran cantidad de metodos se debe a la representacion de la malla, explicada ante-riormente, que hacıa que esta clase fuera la unica que podıa implementar comportamientospropios de las clases Nodo, Arco o Cara.

Se evaluo la posibilidad de cambiar la representacion de las clases Malla, Nodo, Ar-co y Cara. Sin embargo, esta idea se descarto por el costo y riesgo de hacer un cambiotal magnitud en la aplicacion y porque los motivos de eficiencia que llevaron a trabajarcon contenedores e ındices siguieron pesando. Entonces, se decidio mantener la repre-sentacion y cambiar los metodos cuestionados a las clases correspondientes, agregandolescomo argumento la malla. Es decir, los metodos reciben la malla como parametro y puedenpedirle la informacion que necesiten para implementar los comportamientos requeridos.Por ejemplo, la clase Arco ahora implementa el metodo para calcular su largo, pidiendolea la malla los objetos Nodo que componen el arco, para poder obtener la posicion de estos.

De esta forma, aumenta el acoplamiento de las clases Nodo, Arco y Cara con la claseMalla, pues estas clases requieren de esta ultima para implementar sus comportamientos.Sin embargo, se considera que este punto es inevitable, pues refleja la realidad en la queestos elementos geometricos efectivamente estan acoplados.

Uno de los motivos que dificultaba el cambio en la representacion de la malla era laexistencia de metodos publicos que obtenıan los contenedores de nodos, arcos y caras.De este modo, se perjudicaba la independencia entre la representacion de la clase y sususuarios. Para mejorar este aspecto, se reemplazaron tales metodos por otros para obtenerun nodo, arco o cara particular, y no su contenedor. De esta forma, para iterar sobre losnodos de la malla se le pide iterativamente cada nodo, sin comprometer la privacidad dela implementacion.

21

3.3. Discusion sobre la incorporacion de nuevos algo-

ritmos

A continuacion, se explica el proceso llevado a cabo para incorporar nuevos algoritmos,sus dificultades y como se abordaron.

3.3.1. Eliminacion de un nodo

La eliminacion de un nodo de la malla es una operacion que la aplicacion del legadoutiliza al deformar la malla, cuando se produce una inconsistencia que no puede ser repara-da cambiando el vector normal del nodo (como se explico en la seccion 2.2.5). Ademas seutiliza para desrefinar la malla.

El algoritmo para triangulos, implementado en el metodo VertexDeletion, puede en-tenderse como el colapso de un arco en un vertice. Esto se traduce en que se elimina elarco y uno de sus nodos y el otro nodo “hereda” las caras y arcos del nodo borrado. Paraesto se eliminan las dos caras que estaban conectadas por el arco borrado y se modificanlas otras caras a las que pertenecıa el nodo borrado, como se muestra en la figura 3.2

borrar

borrar

reemplazar

modificar

reemplazar

Figura 3.2: VertexDeletion para caras triangulares

El primer enfoque adoptado para adaptar este algoritmo para cuadrilateros fue encon-trar la analogıa con el caso de triangulos. Se identificaron los mismos actores que en elcaso anterior: caras a borrar, caras a modificar, arcos a mantener, etc. y se quiso procederigual que en el caso triangular, como se explica en la figura 3.3.

Sin embargo, este procedimiento no logra los resultados deseados. Para entender loque ocurre, se puede volver a la explicacion intuitiva sobre el procedimiento en una mallatriangular: al colapsar un arco en un nodo, a su vez se colapsa en un arco las dos carasadyacentes al arco borrado. Esto no puede ser replicado en un cuadrilatero, pues al co-lapsar un arco, se forma un triangulo. Dejar la malla mixta no es una opcion pues no

22

borrar

borrar

reemplazar

modificar

reemplazar

Figura 3.3: Generalizacion VertexDeletion para cuadrilateros

permite aplicar ninguno de los algoritmos de modificacion de la malla que estan imple-mentados. La segunda opcion es colapsar dos arcos, en vez de uno, borrando dos de losnodos pertenecientes a las caras a borrar, como se indica en la figura 3.4. En la figura,se muestra una malla inconsistente pues hay un par de arcos en cuya interseccion no hayun nodo. Por lo tanto, el borrar estos dos nodos, adicionales con respecto al algoritmopara triangulos, conlleva modificar tambien el entorno de esos nodos, lo que hace que elproblema deje de ser local y se reproduzca recursivamente, pudiendo no tener solucion.

Figura 3.4: Problema al generalizar VertexDeletion para cuadrilateros

Otra forma de entender esto es dandose cuenta de que el algoritmo para triangulos loque hace es eliminar un nodo y triangular el polıgono que rodeaba al nodo (el formado porlos arcos no incidentes en el nodo, de las caras incidentes en el nodo). Siempre es posiblerealizar este procedimiento pues siempre es posible triangular un polıgono 2. En cambio,no siempre es posible generar una malla de cuadrilateros en un polıgono. De hecho, nose puede generar una malla de cuadrilateros en un polıgono cuyo numero de arcos es impar.

Por otra parte, incluso si solo se trabajase con polıgonos cuyo numero de lados es par,igualmente surgen problemas cuando hay arcos adyacentes colineales, lo que se tiene, por

2El algoritmo realiza una triangulacion particular que en casos especıficos no puede efectuarse, perose podrıa hacer otra triangulacion

23

ejemplo, al generar la malla de un cilindro. En la figura 3.5 se observa que al borrar elnodo central y generar la malla de cuadrilateros, quedan colineales arcos adyacentes ypertenecientes a la misma cara, lo que es inconsistente.

borrar

Figura 3.5: Inconsistencia al generar malla de cuadrilateros: hay arcos colineales

Una posible solucion a este problema es desplazar el nodo que une los arcos colinea-les de modo de que dejen de serlo. El desplazamiento no puede ser infinitesimal pues sepueden producir errores numericos. Este enfoque tiene dos desventajas: puede convertiren concava la cara vecina (si las dos caras se encuentran en la misma situacion) y puedegenerar caras que no pertenezcan a un plano, como se muestra en las figuras 3.6 y 3.7,respectivamente.

Figura 3.6: Problema al desplazar nodo: una cara es concava y la otra convexa

Considerando todo lo anterior, se concluyo que no es posible utilizar para cuadrilaterosun algoritmo analogo al usado para triangulos, por lo que se hizo necesario evaluar lasimplicancias de no contar con este procedimiento para mallas de cuadrilateros. Para elcaso del algoritmo de verificacion, se decidio implementar un nuevo algoritmo que en vezde colapsar un arco en un punto, colapsa en un punto todas las caras incidentes en elnodo. Para el caso del algoritmo de desrefinamiento, se decidio adoptar otra estrategiaque no requiere de esta operacion. Ambas decisiones se discutiran en mas adelante.

En la seccion siguiente se explicara el nuevo algoritmo que colapsa una region en unnodo.

24

noescoplanar

Figura 3.7: Problema al desplazar nodo: Caras dejan de ser coplanares

3.3.2. Colapso de una region en un nodo

La idea del algoritmo es colapsar en un punto las caras aledanas a un nodo. Este pro-cedimiento tiene repercusiones en caras no adyacentes al nodo, por lo que en la practicael algoritmo colapsa una region que rodea al nodo central.

El algoritmo detecta el polıgono que rodea al nodo y desplaza sus vertices hacia laposicion de este nodo central, colapsando el arco que los une y eliminando de esta formalas caras que rodeaban al nodo.

En la figura 3.8 aparece una malla triangular en donde el polıgono que se muestradestacado sera colapsado en el nodo n. En el primer paso, el nodo n1 se desplaza parasuperponerse al nodo n, es decir, se colapsa el arco que une ambos nodos. Al hacer esto,desaparecen las caras c1 y c2. Pero ademas, este movimiento modifica las caras c3 y c6,vecinas de las caras borradas. Otras dos caras, c4 y c5, aumentan su tamano.

En el siguiente paso, el nodo n2 se desplazara hacia n. Esto borrara las caras adyacentesal arco colapsado (el que une a n2 con n). Repitiendo el procedimiento, se obtendra elresultado mostrado en la figura 3.9. El algoritmo puede resumirse como la modificacion detres grupos de caras que forman anillos alrededor del nodo: las que lo rodean directamente,las que son vecinas a las anteriores y las que rodean a estas ultimas. Los dos primeros gru-pos de caras desaparecen, mientras que las caras del tercero aumentan su area, ocupandoel espacio que dejaron las caras borradas, lo que se explica en la misma figura. El algorit-mo no tiene repercusiones en caras mas lejanas pues el polıgono formado por las caras deltercer grupo no cambia, por lo que este algoritmo, al igual que el que colapsa un arco enun nodo, modifica localmente la malla y puede entenderse como una nueva triangulacionde un polıgono que rodea al nodo, salvo que esta vez se considera un polıgono mas grande.

Para el caso de una malla de cuadrilateros, el procedimiento es similar: se desplazanhacia el nodo algunos vertices del polıgono que rodea al nodo. Los vertices del polıgono

25

nc1

c2

c3c4

c5

c6

n1 n2

n

c3c4

c5

c6

n2

Figura 3.8: Desplazamiento del nodo n1 hacia n

Figura 3.9: Algoritmo de colapso de una region de triangulos

26

que se desplazan son los que pertenecen a los arcos incidentes en el nodo central (los queen una malla triangular son todos los vertices del polıgono). En este caso, a diferencia delcaso triangular, se eliminan solo las caras que rodean directamente al nodo. Algunas delas caras que forman el segundo anillo alrededor del nodo aumentan su area, ocupando elespacio dejado por las caras borradas, como se muestra en la figura 3.10.

Figura 3.10: Algoritmo de colapso de una region de cuadrilateros

En el algoritmo explicado en la seccion anterior, el que una de las caras que se borrantuviera dos caras vecinas que ademas son vecinas entre ellas produce un caso degenerado.Para evitar que ocurra, si la malla esta en esa situacion, el procedimiento no se aplica.

En este nuevo algoritmo, este caso es analogo en el caso de mallas triangulares. Para elcaso de mallas de cuadrilateros, el algoritmo puede ser aplicado en este caso, pero generacuadrilateros concavos. En la figura 3.11 se observa que la cara c1 sera borrada y dos desus caras vecinas, c2 y c3, son vecinas entre ellas. Al desplazar los nodos n1 y n2 hacia elnodo n, los arcos a1 y a2 se juntaran, por lo que las caras c2 y c3 compartiran dos arcos,lo que hace que o bien esos dos arcos son colineales, en cuyo caso estamos frente a doscuadrilateros degenerados (tienen tres lados), o bien uno de los cuadrilateros es convexo yel otro concavo (los arcos forman dos angulos, cada uno perteneciente a una de las caras,si uno de los angulos mide menos de 180, el otro debe medir mas de 180), como se muestratambien en la figura.

Tener caras concavas es una desventaja, pero no hace que se descarte el algoritmo. Dehecho, se considera que modificar la malla para que deje de tener caras concavas es unaforma de mejorar la calidad de la malla, por lo que es un buen trabajo futuro incorporaralgoritmos que trabajen en ese sentido.

En particular, se sugieren dos algoritmos de mejoramiento de la malla que abordan elproblema. El primero de ellos consiste en reconocer pares de cuadrilateros vecinos, que

27

c1

n1

n

c2

c3

a1

a2

n2

Figura 3.11: Aparicion de caras concavas al colapsar region

comparten un solo arco, tales que al reemplazar el arco comun por otro de los dos posibles(flipping de arcos), ambos cuadrilateros queden convexos. En la figura 3.12 se muestrael resultado de aplicar dos veces esta idea, a partir de la malla producida al colapsar laregion. Uno de los tres casos de concavidad del ejemplo no pudo ser solucionado por elalgoritmo.

Figura 3.12: Flipping de arcos para mejorar calidad de la malla

Otro algoritmo posible consiste en reconocer pares de cuadrilateros que comparten dosarcos y eliminar esos dos arcos y el nodo que los une. Como los cuadrilateros compartıandos arcos, cada uno de ellos tiene otros dos arcos. La union de los dos pares de arcossobrevivientes forma tambien un cuadrilatero. Este enfoque mejora la calidad de la mallay tambien la desrefina, lo que no siempre es deseable.

28

Si se tiene un caso como el mostrado en la figura 3.11, en que todas las caras a borrartienen caras vecinas que son vecinas entre sı, aplicar el algoritmo de colapso de la regiony posteriormente aplicar este segundo algoritmo de mejoramiento produce un resultadosimilar al obtenido aplicando el algoritmo de colapso en una malla de triangulos.

Detalle de la implementacion y discusion

Para aplicar el algoritmo antes explicado, tanto para mallas de triangulos como parael caso de cuadrilateros, se necesita que la malla cumpla con las condiciones descritas enlos ejemplos, esto es, que se puedan reconocer dos bordes alrededor del nodo a colapsar,en el caso de triangulos, y uno en el caso de cuadrilateros.

Durante el testeo de los metodos implementados se encontraron casos en que la mallase encontraba en una configuracion distinta a la que se esperaba, lo que producıa que losmetodos fallaran. Por ejemplo, en la malla triangular, el caso en que dos caras vecinas yadyacentes al nodo central comparten una tercera cara vecina.

La implementacion de estos metodos resulto mas dificultosa de lo inicialmente estima-do, debido a la necesidad de actualizar las referencias cruzadas entre nodos, arcos y caras.La implementacion es muy sensible al orden en que se hacen las actualizaciones, pues nopuede perderse informacion que luego se necesitara para hacer una posterior actualizacion.

Para evitar complejizar aun mas la implementacion, se opto por crear una copia delos elementos de la malla (nodos, arcos y caras) antes de modificarla. Entonces, en vez dechequear a priori si se cumplen las precondiciones del metodo, se chequea cuando estasson relevantes y, en caso de no cumplirse, se aborta el colapso y se restituye la malla a suestado original.

Esta decision tiene un costo en eficiencia, tanto en tiempo como en espacio, pero seconsidera apropiada para la situacion y la aplicacion sigue corriendo con un uso de recur-sos aceptable, incluso con mallas de decenas de miles de nodos.

Para llevar a cabo el respaldo de los elementos de la malla, se implemento en las clasesNodos, Arcos y Caras el metodo clone que llama al constructor de copia, implementadopara este fin, el que tiene visibilidad protegida. Ademas, se implemento tambien el metodoclone en las clases Nodo, Arco y Cara. La solucion adoptada [11] consiste en hacer unacopia profunda de los contenedores, es decir, crear no solo el contenedor, sino tambienlos objetos contenidos. La utilizacion de los metodos clone en las clases de los objetoscontenidos es una aplicacion del patron Prototype y permite delegar en las subclases lacreacion de la copia de los objetos que son instancia de esas subclases. Esto permite, porejemplo, que la clase Caras se clone correctamente, es decir, respetando el tipo dinamicode las caras que contiene (caras generales, triangulos o cuadrilateros), sin necesidad deque tal clase conozca esa informacion.

29

3.3.3. Verificacion de inconsistencias

La aplicacion del legado proveıa tres algoritmos para desplazar la malla. La principallabor de estos algoritmos es verificar la consistencia de la malla luego del desplazamiento.El primero de ellos no realiza ninguna verificacion, el segundo realiza una verificacion lo-cal, basado en propiedades geometricas de los triangulos y el tercero revisa la consistenciaconsiderando los nodos vecinos. Entonces, este tercer algoritmo, llamado Verificacion deNodos Vecinos, era un buen candidato para extender a mallas de cuadrilateros.

La primera parte de la adaptacion consistio en generalizar la forma en que el algoritmodetecta que existira una colision al desplazar un nodo. El algoritmo crea un pseudocilindroen el que la base inferior es el polıgono que rodea a un nodo central y la base superior seforma por las posiciones futuras de los vertices del polıgono. Es decir, los arcos verticalesdel cilindro son las trayectorias de los nodos que forman el polıgono. Luego detecta si latrayectoria del nodo central chocara con alguna de las caras del cilindro. Se generalizo laforma en que el algoritmo genera este cilindro, pues originalmente la implementacion eravalida solo para el caso de mallas triangulares.

La segunda parte de la adaptacion se relaciona con como el algoritmo soluciona unafutura colision. El primer intento consiste en modificar la trayectoria del nodo central. Siesto falla, entonces elimina el nodo central. Es aquı donde el algoritmo ocupa el metodoVertexDeletion que colapsa un arco en un nodo y que, como se explico anteriormente, noes posible generalizar para mallas de cuadrilateros.

La estrategia adoptada entonces fue crear un nuevo algoritmo de verificacion (Veri-ficacionNodosVecinosColapsoRegion), valido para mallas de triangulos y para mallas decuadrilateros. El algoritmo actua igual que el anterior salvo en el momento en que lacolision no pudo ser solucionada mediante el cambio de la trayectoria del nodo central.

Si no se pudo solucionar la colision, lo que se hace es colapsar en el nodo central laregion que rodea a tal nodo. La intuicion que explica esto es que el desplazamiento de losnodos corresponde al crecimiento del tronco del arbol. Si pese a cambiar la trayectoria delnodo sigue produciendose la colision, entonces no es responsabilidad del nodo, sino de lastrayectorias de los nodos vecinos. Es decir, existe un conjunto de cedulas del arbol (carasde la malla) que interfieren entre sı, por lo que se eliminan todas ellas, absorbidas por lascelulas que las rodean y se mantiene el nodo.

Esta solucion es mas simetrica que la original, que colapsa un arco cualquiera de la re-gion problematica. Por lo tanto el nuevo algoritmo de verificacion y solucion de colisionesutiliza el algoritmo de colapso de una region en un nodo, explicado en la seccion anterior.

Finalmente, los resultados obtenidos con este algoritmo no fueron totalmente satisfac-torios en el caso de mallas con zonas concavas profundas. Por ejemplo, se cuenta con unamalla que modela la superficie de un moai. Este ejemplo constituye el peor caso que setuvo para probar el algoritmo, pues la cara del moai presenta irregularidades (la nariz y

30

la hendidura de los ojos) que hacen que al deformarse se produzcan muchas colisiones,varias que no pueden solucionarse corrigiendo la trayectoria de nodo central, por lo queel algoritmo de colapso debe aplicarse reiteradamente en una zona pequena.

En el caso de esa malla, se observo que se sobrecargan unos pocos nodos de las re-giones crıticas, pues cada vez que se colapsa una region, el nodo central hereda los arcossobrevivientes de las caras borradas. Al repetirse la operacion en otro nodo cercano, estenuevo nodo recibe los arcos del nodo anterior, que ya acumulaba los arcos heredados enlos colapsos anteriores.

Se cree que el comportamiento del algoritmo podrıa mejorar si se le agrega un criteriopara que el colapso se efectue solo si las caras que se colapsan son pequenas. Esta condi-cion modela mejor el comportamiento de las celulas del arbol, que son absorbidas por susvecinas cuando alcanzan un tamano pequeno.

Sin embargo, al probar el algoritmo en mallas mas regulares, que se condicen mejorcon la forma cilındrica del tronco de un arbol, los resultados fueron mas satisfactorios.

3.3.4. Desrefinamiento

El algoritmo de desrefinamiento Edge Collapse que esta implementado para mallastriangulares en la aplicacion del legado, recorre la malla y, para cada cara que cumpleel criterio de aplicacion, colapsa el menor de sus arcos, eliminando las dos caras adya-centes al arco. Para ello utiliza el metodo VertexDeletion que no es extensible a mallas decuadrilateros.

Un enfoque posible es utilizar el nuevo metodo que colapsa una region en un nodo. Elproblema de esto es que el metodo elimina todas las caras que rodean un nodo, es decir,no se puede asegurar que solo se eliminan las caras pequenas. El algoritmo original tiendea eliminar solo las caras pequenas pues de cada cara suficientemente pequena (segun elcriterio elegido), elimina su arco mas pequeno, con lo que ademas de eliminar la cara quecumple el criterio, elimina la otra cara adyacente al arco, pero como el arco es pequeno(el menor arco de una cara pequena debe ser pequeno), la segunda cara tambien debe serlo.

Por lo tanto, si bien es factible hacer un algoritmo de desrefinamiento basado en laeliminacion de regiones de la malla, probablemente su resultado no sera satisfactorio pueselimina demasiadas caras, incluso si se tiene la precaucion de no aplicar el metodo deeliminacion sobre todos los nodos, por ejemplo, excluyendo los nodos que forman el bordede las regiones que ya han sido desrefinadas.

Entonces, el enfoque elegido es triangular la malla de cuadrilateros, anadiendo diago-nales en los cuadrilateros; utilizar el algoritmo de desrefinamiento para mallas triangularesy finalmente hacer que la malla vuelva a ser de cuadrilateros.

31

Esta estrategia no fue implementada, pero sı lo fueron los pasos que la componen.Por lo tanto, el usuario puede reproducir este proceso en la aplicacion. Hay que tenerespecial cuidado en informarle al usuario que al convertir una malla de triangulos en unade cuadrilateros y viceversa, la malla se refina. Por lo tanto, debe considerar esta infor-macion al elegir los criterios que determinan que tanto se desrefina la malla intermedia detriangulos.

3.3.5. Conversion de una malla de triangulos en malla de cuadrilateros

El algoritmo consiste en dividir cada cara triangular en tres cuadrilateros, insertandoun nodo en el centro del triangulo y un nodo en cada arista, como se muestra en la figura3.13.

Figura 3.13: Cuadrangulacion de una cara triangular

Para llevar a cabo el proceso, se recorren las caras de la malla y se dividen sus aristas,creando nuevas caras. Es necesario considerar que al dividir una arista (es decir, eliminarlay crear otras dos) se afecta no solo la cara sobre la cual se esta iterando, sino que tambienla cara vecina a esta, a traves de la arista modificada. Por lo tanto, fue necesario disenarun sistema para guardar, para cada arista original, las dos aristas creadas y el nuevo nodoque las une, de manera que al recorrer las aristas de la cara original, estas se dividan solosi no habıan sido divididas anteriormente.

Como en todos los algoritmos que modifican la malla, hay que tener tambien especialcuidado en actualizar las referencias cruzadas entre los elementos de la malla: nodos, arcosy caras.

Para incorporar esta nueva funcionalidad en la aplicacion, se siguio el diseno existente,es decir, se creo una clase que implementa la interfaz Comando y se agrego una jerarquıapara agregar nuevas implementaciones de este algoritmo, lo que corresponde a la apli-cacion de los patrones Command y Strategy, respectivamente.

Ademas, se creo una jerarquıa de clases para el criterio de calcular el centro del triangu-lo. Se implemento la clase que lo calcula como el baricentro, pero podrıan agregarse nuevoscriterios, como calcularlo como el incentro del triangulo.

32

Finalmente, se agregaron los botones en la interfaz y el cuadro de dialogo para selec-cionar el algoritmo y criterio elegidos.

3.3.6. Conversion de una malla de cuadrilateros en malla detriangulos

Se desarrollo un algoritmo simple para convertir cada cuadrilatero de la malla en dostriangulos, agregando una diagonal. Se tomaron las mismas consideraciones del algoritmoinverso en cuanto a la actualizacion de las referencias cruzadas. Igualmente, se aplicaronlos patrones Command y Strategy y se modifico la interfaz para incorporar esta nuevafuncionalidad.

3.4. Evaluacion del rediseno

Se utilizo nuevamente la herramienta Understand C++, esta vez para obtener lasmetricas de la aplicacion final y compararlas con la aplicacion del legado, para ver elimpacto de los cambios introducidos como resultado de este trabajo de tıtulo.

En primer lugar, se pueden comparar las metricas generales del proyecto, al inicio yal final de este trabajo:

Metrica Valor Inicial Valor Final

Nro. de clases 77 101Nro. de archivos 132 167Nro. de lıneas 12991 16044Nro. de lıneas en blanco 1807 2170Nro. de lıneas de codigo 9245 11394Nro. de lıneas de comentarios 1375 1751Radio Comentarios/Codigo 0.15 0.15

En terminos generales, se observa que se aumento el numero de clases y archivos, pro-ducto de la creacion de las jerarquıas de las clases Cara y Malla y la incorporacion denuevos algoritmos. Se deduce tambien una disminucion del tamano promedio de las clases(de 169 lıneas a 159), lo que se debe, en gran parte, a la creacion de la jerarquıa en laclase Malla, la mas grande del sistema, que disminuyo su tamano aunque se le agregaronnuevos metodos. Se considera importante este aporte, pues, de haber seguido con el mismotamano promedio de las clases, la incorporacion de las nuevas clases hubiera significadola adicion de 1.000 lıneas mas de codigo de las que efectivamente se agregaron, lo quehubiera perjudicado la mantenibilidad del sistema.

Por otra parte, se pueden analizar las Metricas OOP obtenidas. A continuacion seexplican las abreviaciones usadas:

33

Sigla metrica Nombre metrica

LCOM Carencia de cohesionDIT Profundidad de herenciaCBO Acoplamiento entre objetosNOC Numero de hijosRFC Respuesta de una claseWMC Peso de los metodos de una clase

En el Apendice, se incluye el listado completo de las metricas para cada clase del sis-tema, tanto del legado como del actual. Para efectos de evaluar el impacto del rediseno,se mostraran solo las metricas de las clases relevantes.

En las tablas de metricas siguientes se observan las metricas de las clases que fueronmas afectadas en el rediseno, la mayorıa de las cuales ahora forma una jerarquıa. El re-diseno de la clase Malla, que llevo a mover funcionalidades (como el calculo del largo deun arco) desde esa clase a las clases Arco, Nodo o Cara, en general aumento la cohesionde estas clases, pero aumento tambien su acoplamiento con otras clases, lo que era de es-perarse, pues como antes implementaban muy pocos comportamientos, eran poco usadaspor otras clases. Esto mismo se corrobora con el aumento de la respuesta de estas clases,ya que ahora interactuan con mas objetos.

Por otra parte, en las nuevas clases disenadas, se observa que las fabricas de algorit-mos son clases con alto acoplamiento. Esto se explica porque manejan la creacion de losalgoritmos, por lo que se relacionan con las clases que los implementan y las que los usan.Por lo tanto, no es posible disminuir el acoplamiento de estas clases.

Finalmente, analizando la creacion de jerarquıas para las clases Cara y Malla, se obser-va que en el primer caso se aumento la cohesion de la clase, pero tambien su complejidad,lo que repercutio negativamente en su acoplamiento. Esto se explica ademas por la adicionde nuevas funcionalidades.

34

Metricas de la aplicacion del legado:

Class LCOM DIT CBO NOC RFC WMCAlgDesplazamiento 0 0 1 3 2 2AlgDesrefinamiento 0 0 2 1 2 2AlgMejoramiento 0 0 1 1 2 2AlgRefinamiento 0 0 2 2 2 2Malla 77 0 11 0 73 73Arco 50 0 0 0 17 17Cara 62 0 0 0 20 20Nodo 76 0 2 0 18 18

Metricas de la aplicacion actual:

Class LCOM DIT CBO NOC RFC WMCAlgDesplazamiento 0 0 1 2 2 2AlgDesplazamientoMallaCuadrilateros 0 1 1 2 4 2AlgDesplazamientoMallaTriangulos 0 1 1 4 4 2AlgDesrefinamiento 0 0 2 2 2 2AlgDesrefinamientoMallaCuadrilateros 0 1 2 0 4 2AlgDesrefinamientoMallaTriangulos 0 1 2 1 4 2AlgMejoramiento 0 0 1 2 2 2AlgMejoramientoMallaCuadrilateros 0 1 1 0 4 2AlgMejoramientoMallaTriangulos 0 1 1 1 4 2AlgRefinamiento 0 0 2 2 2 2AlgRefinamientoMallaCuadrilateros 0 1 2 0 4 2AlgRefinamientoMallaTriangulos 0 1 2 2 4 2FabricaAlgoritmos 0 0 4 2 9 9FabricaAlgoritmosMallaCuadrilateros 0 1 10 0 19 10FabricaAlgoritmosMallaTriangulos 0 1 16 0 19 10Malla 80 0 12 2 71 71MallaCuadrilateros 0 1 12 0 76 5MallaTriangulos 0 1 16 0 82 11Cara 59 0 6 2 42 42Triangulo 0 1 0 0 48 6Cuadrilatero 0 1 0 0 47 5Arco 52 0 4 0 25 25Nodo 72 0 2 0 24 24

Por otro lado, la clase Malla adolecıa, y sigue haciendolo, de falta de cohesion. Estose explica porque es una clase compleja, donde conviven tanto aspectos topologicos dela malla, como aspectos de su despliegue grafico y aspectos mas conceptuales, como lafabrica de algoritmos. Esto hace que se produzcan particiones de los metodos que abarcanestas areas, disminuyendo la cohesion entre ellos. Tambien influye de manera importantela gran cantidad de getters y setters que esta clase provee, los que por cierto solo accedena una variable de instancia a la vez, formando cada uno de ellos una particion diferente.La creacion de la jerarquıa de la clase Malla practicamente mantuvo el acoplamiento ycomplejidad de la clase, pese al aumento de funcionalidades. Se consideran positivos los

35

valores obtenidos en las metricas que miden esos comportamientos (CBO, RFC y WMC)porque, como se trata de la principal clase del sistema, las nuevas clases que se incorpo-raron interactuan con ella y, pese a esto, esos valores no aumentaron considerablemente.

36

Capıtulo 4

Implementacion

Como se explico anteriormente, la creacion de las jerarquıas de las clases Cara yMalla tuvo amplias repercusiones en el codigo de la aplicacion, implicando cambiar laimplementacion existente y agregar nuevos algoritmos. A continuacion se explica como sellevo a cabo en cada una de las partes relevantes de la aplicacion.

4.1. Generacion de malla

La malla puede ser generada desde una medula ingresada por el usuario, o generadaen forma cilındrica. Para el caso de la malla cilındrica, la aplicacion del legado tenıa im-plementada la opcion con mallas de cuadrilateros, ası es que solo hubo que cambiar lacreacion de los objetos de la clase Cara por objetos de las clases Triangulo o Cuadrilateroy la creacion de los objetos de la clase Malla por objetos de las clases MallaTriangulos oMallaCuadrilateros, segun correspondiera.

La generacion de la malla a partir de una medula se extendio para el caso de mallasde cuadrilateros. Para esto, primero se modifico la interfaz para permitir la eleccion entreuna malla de triangulos y una de cuadrilateros. Luego se agrego un metodo que genera lamalla de cuadrilateros. El algoritmo consiste en generar los anillos de la malla desde abajohacia arriba. Al tener un anillo, se itera sobre el numero de puntos del anillo. Para cadapunto, se reconocen cuatro nodos: el actual, el siguiente en el mismo anillo, el superioral actual y el superior al siguiente del actual, como se muestra en la figura 4.1. Con esosnodos se crea el cuadrilatero, creando tambien los correspondientes arcos.

4.2. Carga de malla

La malla puede ser cargada en cuatro formatos, para todos ellos hay que adaptar elalgoritmo de lectura para que trabaje tambien con mallas de cuadrilateros.

37

Figura 4.1: Generacion de caras cuadrilateras a partir de una medula

En el caso del formato Matlab ya existıa un metodo para cargar mallas de cuadrilateros.El formato almacena nodos y su ubicacion en anillos alrededor de una medula implıcita,por lo que un mismo archivo puede representar una malla de triangulos o de cuadrilateros,dependiendo de como se unen los nodos mediante arcos. Es por esto que el usuario elige eltipo de malla a crear a partir de un archivo en este formato. La aplicacion del legado yatenıa implementada esta funcionalidad, pero se detecto y soluciono un error que dejabala malla inconsistente (mas adelante se detallar).

En el caso de los otros formatos, la estrategia usada fue generalizar el algoritmo exis-tente, en vez de crear otro para el caso de cuadrilateros. De esta forma, se evita duplicarel codigo y por lo tanto se ayuda a la mantenibilidad de la aplicacion. La generalizacionconsistio en detectar el codigo comun para ambos tipos de cara, dejarlo parametrizadocon respecto al numero de lados (tres o cuatro) y separar las partes diferentes segun eltipo de cara, por ejemplo, la creacion del objeto Triangulo o Cuadrilatero.

El formato Geomview ya estaba generalizado y ahora se crean objetos Triangulo,Cuadrilatero o Cara segun si el numero de lados de la cara es tres, cuatro o mayor, res-pectivamente.

En los formatos Comsol y nxyzu la generalizacion es valida para caras triangulares ycuadrilateras. No se considero necesario extenderlo tambien a caras de mas lados, puesese caso no se presenta en las mallas de ejemplo que se tienen (a diferencia del formatoGeomview), pero se considera que ya hecha esta primera generalizacion, las posterioresno presentan gran dificultad.

Para estos dos ultimos formatos se dejo tambien la opcion de que la malla sea mixta,es decir, que este formada por caras triangulares y cuadrilateras. Sin embargo, al igualque en el caso de caras de mas de cuatro lados, la aplicacion no provee algoritmos paramodificar esas mallas, por lo que solo pueden ser visualizadas.

38

4.3. Guardado de malla

Para cada uno de los cuatro formatos de salida de la malla fue necesario adaptar losalgoritmos de guardado para que iteraran sobre los nodos y arcos sin suponer que su car-dinalidad era tres. Ademas, en el caso de los formatos Comsol y nxyzu se cubrio el casoen que la malla es mixta.

4.4. Correccion de errores

Durante el desarrollo del trabajo de esta memoria se encontraron errores heredados dela aplicacion del legado. Ellos tenıan distintos niveles de impacto en la aplicacion, perosı impactaron de forma importante el desarrollo de esta, pues en general eran errores queno se detectan en los casos de prueba usuales, por lo que en un principio fueron atribui-dos a los cambios introducidos durante este desarrollo y se utilizo una gran cantidad detiempo en hacer un seguimiento de los cambios para concluir finalmente que eran erroresheredados.

Esta situacion se produjo porque al cambiar cada parte de la aplicacion se probo sufuncionamiento fabricando mallas pequenas de forma de poder garantizar que la mallagenerada era una instancia valida (revisando sus variables de instancia).

Se considera que fue valioso realizar este chequeo minucioso, pese al tiempo que seutilizo, pues permitio detectar errores que no se notaban al visualizar la malla, lo queexplica que no hayan sido corregidos cuando se desarrollo la aplicacion del legado.

A continuacion se explican los errores encontrados y solucionados:

Ejecucion en modo debug : Uno de los metodos utilizados para graficar la malla che-queaba una precondicion que generalmente no se cumplıa. Por lo tanto, al ejecutarla aplicacion en modo debug (con las instrucciones assert activadas), el programa secaıa. Este error no se detectaba al ejecutar la aplicacion en modo release.

Visualizacion de la malla: Al cargar una malla en que todos los nodos tenıan concen-tracion nula, las caras se graficaban de color negro, en vez del color azul esperado.Esto se debe a que el color de los nodos es proporcional a la concentracion del nodocon respecto a la maxima concentracion de la malla. No se consideraba el caso enque ese maximo era cero, por lo que se producıa una division por cero.

Deformacion de la malla: En el calculo de las normales de las caras faltaba normalizarel vector. Estas normales se utilizan para calcular la normal de los nodos, la quedefine la direccion del desplazamiento del nodo. Por lo tanto, el error hacıa que ladeformacion de la malla no fuera la deseada.

Ademas, se encontro otro error al calcular la normal de los nodos. Esta se calculabacomo la suma de las normales incidentes en el nodo. En el ejemplo de la figura 4.2 se

39

muestra una malla de seis caras triangulares, donde todas las diagonales van desdeel nodo superior izquierdo al nodo inferior derecho. Cada nodo de la malla formaparte de tres caras. Dada la simetrıa del ejemplo, se espera que las normales de losnodos sean radiales y que los nodos pertenecientes a un mismo arco vertical tenganlas mismas normales. Sin embargo no se obtenıa eso, pues se consideraban de igualforma las tres normales de las caras, por lo que un vector se sumaba dos veces.Esto se corrigio considerando que el peso de cada cara en el nodo es proporcional alangulo que forma la cara en ese nodo.

Figura 4.2: Malla de seis caras triangulares

Consistencia de la malla: En el metodo que estaba implementado para generar unamalla de cuadrilateros a partir de un archivo de formato Matlab, se calculaba maluno de los ındices de los arcos que forman la cara. Esto hacıa que la cara registraraque estaba formada por un arco que no informaba que fuera parte de esa cara,pues efectivamente no lo era. Este error no se notaba al visualizar la malla, puesahı se ocupa la informacion de los nodos que componen la cara y esa informacionestaba correcta. Sin embargo, en metodos que recorren los arcos de la cara el errorse hacıa presente. Se soluciono el error y ademas se modifico un metodo que chequeala consistencia de la malla, para que revisara tambien que todas las relaciones entreelementos de la malla fueran simetricas, es decir, en ambos sentidos. Por ejemplo,si un arco se relaciona con una cara, la cara tambien se debe relacionar con el arco.

Deteccion de colisiones: En el algoritmo Verificacion de Nodos Vecinos que detecta ysoluciona las colisiones al deformar la malla no se cubrıa el caso en que algunos delos nodos de la malla no se desplazaran (tuvieran una concentracion nula), por loque la aplicacion se caıa al deformar la malla ocupando ese algoritmo.

40

Capıtulo 5

Ejemplos

5.1. Conversion de malla de triangulos en malla de

cuadrilateros

Figura 5.1: Malla de entrada

41

Figura 5.2: Malla de salida

42

5.2. Conversion de malla de cuadrilateros en malla

de triangulos

Figura 5.3: Malla de entrada

5.3. Algoritmo de colapso de una region

Como se explico anteriormente, este algoritmo, al aplicarse reiteradamente, va crean-do nodos con demasiadas aristas incidentes. Sin embargo, es posible mejorar el resulta-do obtenido aplicando un algoritmo de desrefinamiento. A continuacion, se muestra unejemplo en el que se aplica repetitivamente el algoritmo, para corregir las colisiones quese produciran debido al crecimiento de la malla, luego se aplica un algoritmo de mejo-ramiento y finalmente, uno de desrefinamiento. Con el fin de mejorar el entendimiento delos cambios que va sufriendo la malla luego de cada algoritmo, la malla no se desplazara,sino que se corregiran las colisiones que ocurrirıan si la malla se desplazase.

43

Figura 5.4: Malla de salida

44

Figura 5.5: Malla de salida

45

5.4. Conversion de malla de cuadrilateros en malla

de triangulos

Figura 5.6: Malla de entrada

Luego de colapsar las regiones (figura 5.7), se observa que el proceso desrefino la mallalocalmente, disminuyendo el numero de caras, e hizo que aparecieran caras de area muygrande, con un par de arcos muy grandes en comparacion con el tercero. Se observa queel largo promedio de los arcos es cercano a 1, pero el valor maximo es mayor a 19. Estaconfiguracion llevo a aplicar un algoritmo de desrefinamiento (Lepp-Dealunay), para re-finar las caras con arco mayor a 2. El resultado final del proceso se muestra en la figura 5.8.

46

Figura 5.7: Malla luego de colapsar regiones repetidamente

47

Figura 5.8: Malla luego de algoritmo de refinamiento

48

Capıtulo 6

Conclusiones

El resultado del trabajo desarrollado es una aplicacion capaz de generar, visualizary exportar mallas de cuadrilateros, del mismo modo como ya se hacıa con las mallas detriangulos. Ademas, se pueden aplicar transformaciones sobre las mallas de cuadrilateros:deformacion y conversion a mallas de triangulos. Indirectamente, se pueden tambienaplicar algoritmos de refinamiento y desrefinamiento, pero se requiere convertir las carasen triangulos.

Se considera cumplido el objetivo de esta memoria, en cuanto se extendieron las prin-cipales funcionalidades de la aplicacion a mallas de cuadrilateros y se hizo un diseno quepermite seguir incorporando algoritmos para ambos tipos de malla; incluso permite agre-gar nuevos tipos de malla, sin tener que modificar sustancialmente el codigo existente,sino que solo agregando nuevas clases. Por ejemplo, incorporar mallas mixtas podrıa seruna opcion a explorar.

Por otra parte, se rediseno la principal clase del sistema, la clase Malla, disminuyen-do el numero de metodos que la componen, pese al aumento de funcionalidades, lo queimpacta positivamente en la mantenibilidad de esta clase y del sistema en general. Delmismo modo, la adicion de nuevas clases al sistema, las que interactuan con esta claseprincipal, no implico un aumento de su complejidad ni acoplamiento, lo que tambien es unaporte a la mantenibilidad del sistema. Ası mismo, con la utilizacion del patron AbstractFactory se permitio que la incorporacion de nuevos algoritmos, independientemente deltipo de malla para los que esten hechos, sea un proceso limpio y transparente para lamayor parte del sistema.

Ademas, se hizo una considerable labor en la correccion de errores de la aplicaciondel legado. Mas que la correccion particular de los errores, se valora la implementacionde metodos que permiten comprobar la consistencia de la malla, evaluando, por ejemplo,si las referencias cruzadas entre los nodos, arcos y caras son bilaterales. Ademas, gra-cias a ellos se detecto que algunas de las mallas que se estaban ocupando para probarla aplicacion venıan inconsistentes, lo que ahorro mucho trabajo de debugging. A la vez,esos metodos facilitaron el proceso de testeo de las nuevas funcionalidades implemen-tadas durante este desarrollo. Dicho proceso resulto complejo por la dificultad de asimilar

49

el estado de la malla en un momento dado, debido a la gran informacion que esta posee(al menos, en los ejemplos con los que se trabajo): decenas de miles de nodos, arcos y caras.

Como trabajo futuro se espera la incorporacion de nuevos algoritmos especialmentehechos para mallas de cuadrilateros. A la vez, se requiere un mayor trabajo en los algo-ritmos de deteccion de colisiones, para que, por ejemplo, detecten colisiones entre carasno vecinas. Del mismo modo, como se comprobo con el analisis de la metricas del sis-tema, la clase Malla sigue teniendo problemas de cohesion y acoplamiento, por lo quese debe evaluar la realizacion de un rediseno mayor que, por ejemplo, divida esta clasepara obtener clases mas pequenas y cohesionadas, o cambie la representacion de la malla,anadiendo mayor informacion a las clases Nodo, Arco y Cara, de forma de aminorar lasresponsabilidades que actualmente estan delegadas en la clase Malla. Ambas propuestasde rediseno de la clase Malla deben ser evaluadas cuidadosamente, pues, si bien conllevanlos beneficios antes planteados, implican tambien costos en eficiencia del programa y cos-tos de desarrollo, al afectar estos cambios a toda la aplicacion, por estar justamente estaclase altamente acoplada.

50

Bibliografıa

[1] Marshall Bern and David Eppstein. Quadrilateral meshing by cir-cle packing. Sixth International Meshing Roundtable (Park City, Utah),http://www.cs.berkeley.edu/ jrs/mesh/present.html, pages 7–19, 1997.

[2] Ted Blacker and Michael Stephenson. Paving: a new approach to automated quadri-lateral mesh generation. International Journal for Numerical Methods in Engineering(ISSN 0029-5981), pages 811–812, 1991.

[3] Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. Design patternselements of reusable object-oriented software, version web. Addison-Wesley LongmanPublishing, 1997.

[4] Nancy Hitschfeld. Apunte de curso [en lınea]. CC60Q: Seminario de GeometrıaComputacional, clase 15. Pagina web: http://www.dcc.uchile.cl/ cc60q, 2001.

[5] Ricardo Medina. Modelador de cambios en la geometrıa de objetos utilizando mallasgeometricas. Memoria para optar al tıtulo de Ingeniero Civil en Computacion, 2005.

[6] Joseph O’Rourke. Computational geometry in c. Cambridge University Press, 1998.

[7] Marıa Cecilia Rivara. New longest-edge algorithms for the refinement and/or im-provement of unstructured triangulations. International Journal for Numerical Meth-ods in Engineering, pages 40:3313–3324, 1997.

[8] Stefan Schirra. Robustness and precision issues in geometric computation. Versionpreliminar de un capıtulo de ‘In Handbook of Computational Geometry’, J.-R. Sackand J. Urrutia, Eds. Elsevier Science Publishers, B. V. North-Holland, Amsterdam,The Netherlands, pages 1–26, 1999.

[9] Jonathan Shewchuk. Lecture notes on delaunay mesh generation. Pagina web:http://www.cs.berkeley.edu/ jrs/meshpapers/delnotes.ps.gz, pages 3–5, 1999.

[10] Nicolas Silva. Modelamiento del crecimiento de arboles usando mallas de superficie.Memoria para optar al tıtulo de Ingeniero Civil en Computacion, 2007.

[11] Venkat Subramaniam. Why copying an object is a terrible thing to do? [en lınea].http://www.agiledeveloper.com/articles/cloning072002.htm.

51

Apendices

A . Formatos de archivos de entrada y salida

Figura 6.1: Malla que se representara en distintos formatos

La aplicacion importa y exporta mallas en distintos formatos. A continuacion se ex-plican los formatos utilizados. Esta informacion se obtuvo analizando el codigo de laaplicacion y los archivos de mallas y se registra aquı pues se considera que sera de ayudapara futuras extensiones de la aplicacion.

Se ejemplificaran los formatos con la malla mostrada en la figura 6.1.

Comsol - Extension cms 1: El archivo se divide en dos secciones: coordenadas y ele-mentos. La primera lınea indica el inicio de la seccion de coordenadas. A partirde la segunda lınea, en cada lınea se encuentran las coordenadas x,y,z de un nodode la malla. Luego, hay una lınea que indica el inicio de la seccion de elementos yposteriormente en cada lınea se encuentra la informacion de una cara. La cara seespecifica indicando los ındices 1-basados de los nodos que la componen, segun elorden en que los nodos fueron especificados en la primera seccion.

52

Archivo malla.cms 1

% Coordinates

10 0 0

0 0 5

0 0 -5

10 10 0

0 10 5

0 10 -5

% Elements (triangular)

2 5 1

5 4 1

3 6 2

6 5 2

1 4 3

4 6 3

Matlab - Extension txt: Este formato se utiliza solo para mallas tubulares (es decir,con anillos alrededor de una medula). Al cargar el archivo, el usuario indica el numerode anillos de la malla y la cantidad de puntos por cada anillo. El archivo se divide encuatro secciones. Primero estan las coordenadas x de todos los nodos, luego las z ylas y. Finalmente, estan las concentraciones de los nodos. No son relevantes los saltosde lınea en el archivo, pero para un mejor entendimiento, se tiene la convencion deque cada lınea del archivo tiene los datos de un anillo de la malla.

En este formato no existe una seccion donde se indique que nodos forman cadacara, sino que esto se deduce de la ubicacion de los nodos en los anillos. Es por estoque el mismo archivo puede representar una malla de triangulos o de cuadrilateros,dependiendo de como se unen los nodos mediante arcos.

Archivo malla.txt

10 0 0

10 0 0

0 5 -5

0 5 -5

0 0 0

10 10 10

1 1 1

0 0 0

nxyzu - Extension txt: La informacion de la malla se divide en cuatro archivos: nx,ny, nz y u. Por convencion, al final del nombre del archivo se indica de cual delos cuatro tipos es el archivo. Cada archivo tiene tres secciones. Las primeras dossecciones son iguales al formato Comsol y son las mismas en los cuatro archivos. Latercera seccion tiene las coordenadas del vector normal y la concentracion de cadanodo. En el archivo nx esta la coordenada x de las normales de los nodos, en elmismo orden en que se listan los nodos en la primera seccion. Es analogo para ny ynz. En el archivo u esta la concentracion de hormona en el nodo, es decir, el modulo

53

del vector desplazamiento del nodo.

Archivo malla nx.txt Archivo malla ny.txt

% Coordinates % Coordinates

10 0 0 10 0 0

0 0 5 0 0 5

0 0 -5 0 0 -5

10 10 0 10 10 0

0 10 5 0 10 5

0 10 -5 0 10 -5

% Elements (triangular) % Elements (triangular)

1 5 2 1 5 2

1 4 5 1 4 5

2 6 3 2 6 3

2 5 6 2 5 6

3 4 1 3 4 1

3 6 4 3 6 4

% Data (nx) % Data (ny)

1.000000 0.00000

-0.525731 0.00000

-0.525731 0.00000

1.000000 0.00000

-0.525731 0.00000

-0.525731 0.00000

54

Archivo malla nz.txt Archivo malla u.txt

% Coordinates % Coordinates

10 0 0 10 0 0

0 0 5 0 0 5

0 0 -5 0 0 -5

10 10 0 10 10 0

0 10 5 0 10 5

0 10 -5 0 10 -5

% Elements (triangular) % Elements (triangular)

1 5 2 1 5 2

1 4 5 1 4 5

2 6 3 2 6 3

2 5 6 2 5 6

3 4 1 3 4 1

3 6 4 3 6 4

% Data (nz) % Data (u)

0.000000 1.000000

0.850651 1.000000

-0.850651 1.000000

0.000000 0.000000

0.850651 0.000000

-0.850651 0.000000

Geomview - Extension off: Las primeras dos lıneas del archivo son informativas, laprimera indica que se trata de un archivo en formato off y la segunda indica elnumero de nodos, caras y arcos de la malla. El numero de arcos no se ocupa, sino quese deduce de la topologıa de la malla. Las siguientes lıneas contienen las coordenadasde los nodos y las ultimas lıneas corresponden a las caras. El primer numero de lalınea de una cara indica el numero de lados de la cara, luego se indican los ındices 0-basados de los nodos que componen la cara. Opcionalmente se puede indicar tambienel color de la cara en formato RGB. La aplicacion lee y almacena el color de la cara,si es proporcionado, pero no lo utiliza al graficar la malla. En el ejemplo, la mitadde las caras tienen color rojo y la otra mitad verde.

55

Archivo malla.off

OFF

6 6 12

10 0 0

0 0 5

0 0 -5

10 10 0

0 10 5

0 10 -5

3 0 4 1 1 0 0

3 0 3 4 1 0 0

3 1 5 2 1 0 0

3 1 4 5 0 1 0

3 2 3 0 0 1 0

3 2 5 3 0 1 0

Debug - Extension mll: Este formato se utiliza para depurar la aplicacion. En el semuestra toda la informacion de la malla. La primera lınea indica que se que se tratade un archivo de formato Debug. La segunda lınea indica el numero de nodos, carasy arcos de la malla. La lınea siguiente es similar a la anterior, pero se limita a losnodos, caras y arcos validos (es decir, sin incluir los elementos borrados). A partirde la cuarta lınea se listan los nodos, indicando las caras y arcos a los que perteneceel nodo, la normal y la concentracion. Luego se listan los arcos, indicando los nodosque lo forman y las caras de las que forma parte. Finalmente se listan las caras de lamalla, junto con el numero de lados de la cara; los arcos que la conforman, los que asu vez indican los nodos que los conforman; la normal de la cara y la concentracionde la cara.

En el ejemplo, por razones de espacio, se cambiaron las palabras Nodos, Nodo, Caras,Cara, Arcos, Arco, Normal y Concentracion por N s, N, Cs, C, As, A, Nor y Con,respectivamente.

56

Archivo malla.mllMLL (Debug file)6 6 126 6 12N{0}=(10,0,0) Cs{0,1,4} As{0,2,3,10} Nor=(1,0,0) Con={1}N{1}=(0,0,5) Cs{0,2,3} As{1,2,5,7} Nor=(-0.525,0,0.850) Con={1}N{2}=(0,0,-5) Cs{2,4,5} As{6,7,9,10} Nor=(-0.525,0,-0.850) Con={1}N{3}=(10,10,0) Cs{1,4,5} As{3,4,9,11} Nor=(1,0,0) Con={1}N{4}=(0,10,5) Cs{0,1,3} As{0,1,4,8} Nor=(-0.525,0,0.850) Con={1}N{5}=(0,10,-5) Cs{2,3,5} As{5,6,8,11} Nor=(-0.525,0,-0.850) Con={1}A{0} Ns{0,4} Cs{0,1}A{1} Ns{4,1} Cs{0,3}A{2} Ns{1,0} Cs{0,-1}A{3} Ns{0,3} Cs{1,4}A{4} Ns{3,4} Cs{1,-1}A{5} Ns{1,5} Cs{2,3}A{6} Ns{5,2} Cs{2,5}A{7} Ns{2,1} Cs{2,-1}A{8} Ns{4,5} Cs{3,-1}A{9} Ns{2,3} Cs{4,5}A{10} Ns{0,2} Cs{4,-1}A{11} Ns{5,3} Cs{5,-1}C{0} 3 Ns{0,4,1} As{0:0-->4,1:4-->1,2:1-->0} Nor=(0.447,0,0.894) Con=3C{1} 3 Ns{0,3,4} As{3:0-->3,4:3-->4,0:0-->4} Nor=(0.447,-0,0.894) Con=3C{2} 3 Ns{1,5,2} As{5:1-->5,6:5-->2,7:2-->1} Nor=(-1,-0,-0) Con=3C{3} 3 Ns{1,4,5} As{1:4-->1,8:4-->5,5:1-->5} Nor=(-1,0,0) Con=3C{4} 3 Ns{2,3,0} As{9:2-->3,3:0-->3,10:0-->2} Nor=(0.447,0,-0.894) Con=3C{5} 3 Ns{2,5,3} As{6:5-->2,11:5-->3,9:2-->3} Nor=(0.447,0,-0.894) Con=3

B . Patrones utilizados o analizados en el desarrollo

B .1. Command

Figura 6.2: Patron Command

57

B .2. Strategy

Figura 6.3: Patron Strategy

B .3. Abstract Factory

Figura 6.4: Patron Abstract Factory

58

B .4. Bridge

Figura 6.5: Patron Bridge

B .5. Prototype

Figura 6.6: Patron Prototype

59

C . Metricas de la aplicacion del legado

Abreviaciones usadas:

Sigla metrica Nombre metrica

LCOM Carencia de cohesionDIT Profundidad de herenciaCBO Acoplamiento entre objetosNOC Numero de hijosRFC Respuesta de una claseWMC Peso de los metodos de una clase

Metricas del sistema:

Class LCOM DIT CBO NOC RFC WMCAdapterComputationalGeometry 0 0 3 0 4 4AlgAlmacenamiento 0 0 1 4 2 2AlgDesplazamiento 0 0 1 3 2 2AlgDesrefinamiento 0 0 2 1 2 2AlgGeneracion 0 0 1 6 2 2AlgMejoramiento 0 0 1 1 2 2AlgRefinamiento 0 0 2 2 2 2AlmacenaToComsol 1 0 1 6 0 4 2AlmacenaToMllDebug 0 1 9 0 4 2AlmacenaToOff 0 1 7 0 4 2AlmacenaToXYZU 0 1 7 0 4 2AnguloMinimo 0 1 1 0 4 2Arco 50 0 0 0 17 17Arcos 50 0 1 0 13 13AreaCara 0 1 1 0 4 2Cara 62 0 0 0 20 20Caras 47 0 1 0 11 11Comando 50 0 1 8 4 4Criterio 0 0 1 4 2 2Deformar 0 1 5 0 7 3DelaunayLongestEdgeBisection 0 1 3 0 4 2DesrefinamientoEdgeCollapse 0 1 3 0 4 2Desrefinar 0 1 6 0 7 3DistribuirHormona 73 1 9 0 13 9GeneraCilindro 50 1 9 0 7 5GeneraFromArchivosXYZU 0 1 10 0 4 2GeneraFromComsol 1 0 1 9 0 4 2GeneraFromMatLab 31 1 8 0 6 4GeneraFromMedula 57 1 9 0 7 5

60

Class LCOM DIT CBO NOC RFC WMCGeneraFromOFF 0 1 9 0 4 2Generar 0 1 7 0 9 5Guardar 16 1 6 0 7 3GUIDialogAbrirMatlab 0 2 2 0 8 6GUIDialogAbrirMatlab glade 50 1 8 1 2 2GUIDialogCambios 0 2 5 0 14 9GUIDialogCambios glade 80 1 16 1 5 5GUIDialogDesrefinar 0 2 2 0 11 7GUIDialogDesrefinar glade 75 1 14 1 4 4GUIDialogDistribuirHormona 0 2 1 0 6 4GUIDialogDistribuirHormona glade 50 1 10 1 2 2GUIDialogInformacion 0 2 2 0 5 2GUIDialogInformacion glade 66 1 11 1 3 3GUIDialogNuevaMalla 0 2 6 0 16 12GUIDialogNuevaMalla glade 75 1 15 1 4 4GUIDialogRefinar 0 2 2 0 17 12GUIDialogRefinar glade 80 1 14 1 5 5GUIVentanaPrincipal 63 2 26 0 62 32GUIVentanaPrincipal glade 96 1 22 1 30 30InformacionMalla 28 0 5 0 7 7Informar 50 1 2 0 11 7LargoArcoMaximo 0 1 1 0 4 2LargoArcoMinimo 0 1 1 0 4 2Lepp 0 0 1 0 1 1LeppDelaunay 0 1 7 0 7 5Malla 77 0 11 0 73 73MejDelaunay 0 1 2 0 4 2Mejorar 0 1 3 0 7 3Nodo 76 0 2 0 18 18NodoProb 25 0 0 0 3 3Nodos 56 0 3 0 18 18NoVerificacion 0 1 2 0 4 2Polinomio 50 0 0 0 15 15Punto 44 0 0 0 9 9Refinar 0 1 8 0 7 3SegmentTriangleIntersection 80 0 0 0 15 15SimpleGLScene 87 1 14 0 24 23Vect 13 0 1 0 15 15VerificacionLocal 25 1 4 0 6 4VerificacionNodosVecinos 50 1 8 0 9 7

61

D . Metricas de la aplicacion del final

Class LCOM DIT CBO NOC RFC WMCAdapterComputationalGeometry 0 0 3 0 4 4AlgAlmacenamiento 0 0 1 4 2 2AlgCentroTriangulo 75 0 3 1 4 4AlgDesplazamiento 0 0 1 2 2 2AlgDesplazamientoMallaCuadrilateros 0 1 1 2 4 2AlgDesplazamientoMallaTriangulos 0 1 1 4 4 2AlgDesrefinamiento 0 0 2 2 2 2AlgDesrefinamientoMallaCuadrilateros 0 1 2 0 4 2AlgDesrefinamientoMallaTriangulos 0 1 2 1 4 2AlgGeneracion 0 0 1 6 2 2AlgMejoramiento 0 0 1 2 2 2AlgMejoramientoMallaCuadrilateros 0 1 1 0 4 2AlgMejoramientoMallaTriangulos 0 1 1 1 4 2AlgRefinamiento 0 0 2 2 2 2AlgRefinamientoMallaCuadrilateros 0 1 2 0 4 2AlgRefinamientoMallaTriangulos 0 1 2 2 4 2AlgTriangulacion 0 0 1 0 2 2AlmacenaToComsol 1 0 1 4 0 4 2AlmacenaToMllDebug 0 1 6 0 4 2AlmacenaToOff 0 1 4 0 4 2AlmacenaToXYZU 0 1 5 0 4 2AnguloMinimo 0 1 2 0 4 2Arco 52 0 4 0 25 25Arcos 51 0 1 0 16 16AreaCara 0 1 2 0 4 2Baricentro 0 1 6 0 7 3Cara 59 0 6 2 42 42Caras 48 0 1 0 13 13Comando 50 0 1 10 4 4Criterio 0 0 1 4 2 2Cuadrangular 37 1 4 0 8 4Cuadrilatero 0 1 0 0 47 5Deformar 0 1 3 0 7 3DelaunayLongestEdgeBisection 0 2 4 0 6 2DesrefinamientoEdgeCollapse 0 2 4 0 6 2Desrefinar 0 1 6 0 7 3DistribuirHormona 73 1 7 0 13 9FabricaAlgoritmos 0 0 4 2 9 9FabricaAlgoritmosMallaCuadrilateros 0 1 10 0 19 10FabricaAlgoritmosMallaTriangulos 0 1 16 0 19 10GeneraCilindro 50 1 13 0 7 5

62

Class LCOM DIT CBO NOC RFC WMCGeneraFromArchivosXYZU 0 1 14 0 4 2GeneraFromComsol 1 0 1 13 0 4 2GeneraFromMatLab 31 1 12 0 6 4GeneraFromMedula 57 1 13 0 10 8GeneraFromOFF 0 1 13 0 4 2Generar 0 1 7 0 9 5Guardar 16 1 6 0 7 3GUIDialogAbrirMatlab 0 2 2 0 8 6GUIDialogAbrirMatlab glade 50 1 8 1 2 2GUIDialogAlgCentro 0 2 1 0 5 3GUIDialogAlgCentro glade 50 1 8 1 2 2GUIDialogCambios 80 2 6 0 15 10GUIDialogCambios glade 80 1 16 1 5 5GUIDialogDesrefinar 0 2 2 0 11 7GUIDialogDesrefinar glade 75 1 14 1 4 4GUIDialogDistribuirHormona 0 2 1 0 6 4GUIDialogDistribuirHormona glade 50 1 10 1 2 2GUIDialogInformacion 0 2 2 0 5 2GUIDialogInformacion glade 66 1 11 1 3 3GUIDialogNuevaMalla 0 2 6 0 16 12GUIDialogNuevaMalla glade 75 1 15 1 4 4GUIDialogRefinar 0 2 2 0 17 12GUIDialogRefinar glade 80 1 14 1 5 5GUIVentanaPrincipal 70 2 34 0 66 34GUIVentanaPrincipal glade 96 1 25 1 32 32InformacionMalla 28 0 4 0 7 7Informar 50 1 2 0 11 7LargoArcoMaximo 0 1 3 0 4 2LargoArcoMinimo 0 1 3 0 4 2Lepp 0 0 2 0 1 1LeppDelaunay 0 2 6 0 9 5Malla 80 0 12 2 71 71MallaCuadrilateros 0 1 12 0 76 5MallaTriangulos 0 1 16 0 82 11MejDelaunay 0 2 2 0 6 2Mejorar 0 1 3 0 7 3Nodo 72 0 2 0 24 24NodoProb 25 0 0 0 3 3Nodos 56 0 3 0 20 20NoVerificacion 0 2 1 0 8 2Polinomio 50 0 0 0 15 15Punto 45 0 0 0 11 11Refinar 0 1 7 0 7 3SegmentTriangleIntersection 80 0 0 0 15 15

63

Class LCOM DIT CBO NOC RFC WMCSimpleGLScene 87 1 12 0 24 23Triangular 50 1 3 0 8 4Triangulo 0 1 0 0 48 6Vect 11 0 1 0 17 17VerificacionLocal 25 2 2 0 8 4VerificacionNodosVecinos 50 2 8 0 11 7VerificacionNodosVecinosColapsoRegion 52 2 7 0 13 7

64