CIERRES CONVEXOS APROXIMADOS - dma.fi.upm.es · (también conocido como Envolvente Convexa o Convex Hull) al menor conjunto convexo del plano que contiene a S. De forma intuitiva

CIERRES CONVEXOS APROXIMADOS AUTOR: Oscar Plaza Hernández TUTOR: Manuel Abellanas Oar

A mis familiares y amigos por su apoyo incondicional

Cierres convexos aproximados Bandas, Cuadrículas, Rayos

- 3 -

TABLA DE CONTENIDOS.

1. INTRODUCCIÓN.................................................................................................................................. 5 2. OBJETIVO. ............................................................................................................................................ 5 3. ESTUDIO TEÓRICO............................................................................................................................ 6

3.1. CIERRE CONVEXO. ...................................................................................................................... 6 3.2. ALGORITMO DEL SCAN DE GRAHAM..................................................................................... 6 3.3. ALGORITMO DE ANDREW. ........................................................................................................ 8 3.4. LAS APROXIMACIONES AL CIERRE CONVEXO. ................................................................... 8 3.5. ALGORITMO K BANDAS POR DEFECTO (A.B.D.). .................................................................. 8

3.5.1. Descripción del algoritmo. ....................................................................................................... 9 3.5.2. Seudocódigo.............................................................................................................................. 9 3.5.3. Complejidad............................................................................................................................ 10 3.5.4. Error en la aproximación por defecto del algoritmo de bandas............................................. 16

3.6. ALGORITMO K BANDAS POR EXCESO (A.B.E.). ................................................................... 18 3.6.1. Descripción del algoritmo. ..................................................................................................... 18 3.6.2. Seudocódigo............................................................................................................................ 19 3.6.3. Complejidad............................................................................................................................ 19 3.6.4. Error en la aproximación por exceso del algoritmo de bandas. ............................................ 25

3.7. ALGORITMO K X K CUADRÍCULAS POR DEFECTO (A.C.D). .............................................. 27 3.7.1. Descripción del algoritmo. ..................................................................................................... 27 3.7.2. Seudocódigo............................................................................................................................ 27 3.7.3. Complejidad............................................................................................................................ 28 3.7.4. Error en la aproximación por defecto en algoritmo de cuadrículas. ..................................... 34

3.8. ALGORITMO K X K CUADRÍCULAS POR EXCESO (A.C.E.). ................................................ 36 3.8.1. Descripción del algoritmo. ..................................................................................................... 36 3.8.2. Seudocódigo............................................................................................................................ 36 3.8.3. Complejidad............................................................................................................................ 37 3.8.4. Error en la aproximación por exceso del algoritmo de cuadrículas. ..................................... 43

3.9. ALGORITMO K RAYOS POR DEFECTO (A.R.D.). ................................................................... 45 3.9.1. Descripción del algoritmo. ..................................................................................................... 45 3.9.2. Seudocódigo............................................................................................................................ 45 3.9.3. Complejidad............................................................................................................................ 46 3.9.4. Error en la aproximación por defecto en algoritmo de rayos. ............................................... 51

3.10. ALGORITMO K RAYOS POR EXCESO (A.R.E.)..................................................................... 54 3.10.1. Descripción del algoritmo. ................................................................................................... 54 3.10.2. Seudocódigo.......................................................................................................................... 54 3.10.3. Complejidad.......................................................................................................................... 55 3.10.4. Error en la aproximación por exceso del algoritmo de rayos. ............................................. 61

4. ANÁLISIS, DISEÑO E IMPLEMENTACIÓN................................................................................. 64 4.1. ANÁLISIS...................................................................................................................................... 64 4.2. DISEÑO E IMPLEMENTACIÓN. ................................................................................................ 65 4.3. OPTIMIZACIÓN DEL DISEÑO CON PATRONES. ................................................................... 68

4.3.1. Definición de patrón. .............................................................................................................. 68 4.3.2. Descripción de un patrón. ...................................................................................................... 69 4.3.3. Patrón Factory Method (SeleccionAlgoritmoCommand - AlgoritmoEnPasosYenHilos). ..... 69 4.3.4. Patrón State (AlgoritmoEnPasos -EstadosPaso).................................................................... 70 4.3.5. Patrón Composite (ElementoGrafico - Compuesto). ............................................................. 71 4.3.6. Patrón Observer (Papel – ZonaGrafica). ............................................................................... 73


- 4 -

4.3.7. Patrón Builder (AplicacionCliente - DirectorIU - BuilderIU - IU). .......................................74 4.3.8. Patrón Command (AplicacionCliente–Llamador-CommandConcrete). .................................75

5.1. ACCEDIENDO A LA APLICACIÓN. ..........................................................................................77 5.2. INTRODUCIENDO NUESTRO PROBLEMA EN LA APLICACIÓN. .......................................79 5.3. OBSERVANDO LA CONSTRUCCIÓN DE LA SOLUCIÓN. ....................................................82 5.4. COMPARANDO QUÉ ALGORITMO ES MÁS RÁPIDO. ..........................................................85

6. CONCLUSIONES. ...............................................................................................................................88 6.1. LÍNEAS FUTURAS. ......................................................................................................................88

7. ACRÓNIMOS.......................................................................................................................................89 8. TABLAS Y FIGURAS. ........................................................................................................................90 9. BIBLIOGRAFÍA Y ENLACES...........................................................................................................94


- 5 -

1. INTRODUCCIÓN.

En Geometría Computacional existen diversos algoritmos que obtienen el Cierre Convexo de una nube de puntos de forma eficiente, complejidad O(n log n), pero para ciertas aplicaciones, que deben procesar un gran volumen de datos, el tiempo de ejecución excede el tiempo real disponible. En esta situación, la Ingeniería Algorítmica aporta soluciones alternativas que, en este caso, son aproximaciones a la solución. En estas aproximaciones no se garantiza el resultado, aunque en muchos casos se obtiene el resultado exacto. Pero sí se puede garantizar que la aproximación sea por exceso o por defecto, lo que dependiendo de la aplicación es importante. Por ejemplo, en el procesado de imágenes, en problemas de localización, en el calculo de trayectorias de robots.

En este contexto se encuentran los siguientes algoritmos y que son los que se desea implementar y enseñar;

• Algoritmo k Bandas por Defecto.(ABD) • Algoritmo k Bandas por Exceso.(ABE) • Algoritmo k X k Cuadrículas por Defecto.(ACD) • Algoritmo k X k Cuadrículas por Exceso.(ACE) • Algoritmo k Rayos por Defecto.(ARD) • Algoritmo k Rayos por Exceso.(ARE)

Estos algoritmos son de salida sensitiva; Esto significa que el resultado o salida de los algoritmos podrán variar en función del valor del parámetro de entrada k. En estos casos al aumentar k aumentamos el tiempo de ejecución de los algoritmos aunque también aumentamos el grado de precisión del resultado.

2. OBJETIVO. Los objetivos de este trabajo son principalmente dos; el primero es desarrollar una aplicación con fines autodidácticos sobre los seis algoritmos de Geometría Computacional anteriormente relacionados, con un coste de distribución bajo y de licencia libre. Y el segundo realizar un estudio sobre la mejora en los tiempos de ejecución de cada uno de los algoritmos. Para llamar la atención del usuario se permitirá a este introducir los puntos que desee sobre el dibujo con el ratón y estos formaran la nube de “puntos dato” sobre la que se calculará el Cierre Convexo Aproximado.

El usuario también podrá seleccionar uno de los seis algoritmos para que sea este el que se ejecute sobre sus puntos.


- 6 -

Además para facilitar el entendimiento de dichos algoritmos el usuario debe poder ejecutar paso a paso y con vuelta hacia atrás cada uno de los algoritmos y poder ir observando gráficamente y textualmente cada uno de los pasos dados.

El programa deberá facilitar tiempos de ejecución de los distintos algoritmos

para poder realizar un estudio comparativo sobre el tiempo que tarda en ejecutar cada uno de los algoritmos (una implementación concreta) sobre una misma nube de puntos. De esta forma podremos obtener una idea del comportamiento de los algoritmos, puesto que el tiempo de ejecución de un programa sobre una maquina esta afectado por muchos factores (velocidad de CPU, número de programas ejecutándose simultáneamente, política de reparto de tiempos de procesador por parte del S.O., etc...)

3. ESTUDIO TEÓRICO.

3.1. CIERRE CONVEXO. Definiciones:

• Un subconjunto de puntos S del plano se dice que es convexo si para cualesquiera dos puntos de S, el segmento que los une está contenido en S.

• Dado S, un subconjunto de puntos del plano. Se llama Cierre Convexo (también conocido como Envolvente Convexa o Convex Hull) al menor conjunto convexo del plano que contiene a S.

De forma intuitiva el Cierre Convexo es el que marcaría una goma elástica al soltarla sobre un tablero con clavos que representarían los puntos del conjunto S.

Fig. 3.1.1. Definición intuitiva de Cierre Convexo.

3.2. ALGORITMO DEL SCAN DE GRAHAM. Para el calculo del Cierre Convexo existen diversos algoritmos pero vamos a estudiar uno de los más eficientes como es éste desarrollado por Graham a finales de los 60.


- 7 -

Primero el algoritmo halla un punto p0 interior al cierre y ordena el resto de puntos de la nube angularmente en sentido positivo alrededor de él. Después se recorre la lista ordenada de puntos, y se van eliminando los puntos interiores al Cierre de esa lista. Al finalizar los puntos que queden en la lista serán los vértices del Cierre Convexo en el orden deseado. Como punto de inicio p0 se escoge uno que pertenezca al Cierre Convexo, para asegurarnos de ello cogemos el punto más bajo y en caso de empate el que este situado más a la derecha.

Fig. 3.2.1. Ordenación de puntos para el scan de Graham.

A continuación ordenamos los puntos de S en sentido contrario a las agujas del reloj según la pendiente que forma el rayo de p0 al punto que se esta ordenando. Una vez ordenada la lista de puntos se recorre analizando tripletas de puntos consecutivos (Inicial, Medio, Final) con el fin de ver si existe un giro a la izquierda o no, si existe un giro a la izquierda significa que vamos bien encaminados en la construcción del Cierre y debemos continuar seleccionando una nueva tripleta donde Medio pasara a ser Inicial, Final pasara a ser Medio y el siguiente punto en la lista pasara a ser Final. Si el giro no es a la izquierda significa que tenemos un punto en nuestra lista Cierre provisional que no pertenece al Cierre y debemos retroceder y quitarlo de esa lista, es decir, Medio se elimina, el punto Inicio pasa a ser Medio, el punto anterior pasa a ser Inicio y el punto siguiente el Final. La lista obtenida al finalizar el recorrido por todos los puntos será la lista de vértices del Cierre Convexo.

Analizando la complejidad del algoritmo vemos que; Para el primer paso (elección de un punto inicial) elegimos el primer punto de la

lista, con lo que podemos decir que la complejidad es O(1). Para el segundo paso (ordenación de los puntos de S respecto a p0) podemos usar

un algoritmo de ordenación como por ejemplo Quick Sort, el cual es de complejidad esperada O(n log n).

Para el tercer paso (recorrido de lista por tripletas pero avanzando un solo punto cada vez) el número de comprobaciones para ver si es un giro a la izquierda o no, es de n así que O(n).

De esta forma la complejidad del algoritmo del scan de Graham es O(n log n). Donde n sería el número de puntos de la nube.


- 8 -

3.3. ALGORITMO DE ANDREW. Como una modificación al algoritmo del scan de Graham aparece el algoritmo de Andrew que usa el scan de Graham pero hace una preordenación diferente. Primero se determinan los puntos más a la izquierda y más a la derecha de la nube de puntos, y se construye una línea que pase por ellos. Después se clasifican el resto de puntos en dos subconjuntos formados uno por los puntos superiores a la línea trazada anteriormente y otro con los puntos inferiores a la misma. El subconjunto inferior dará lugar a una cadena poligonal (Cierre Inferior) monótona respecto al eje X; de manera similar el subconjunto superior da lugar a una cadena análoga (Cierre Superior), y la concatenación de estas dos cadenas será el Cierre Convexo. Para construir el Cierre Superior, los puntos se preordenan de mayor a menor abscisa y posteriormente se aplica el scan de Graham sobre este subconjunto, esto es una particularización del algoritmo original de Graham al que el punto inicial p0 se le sitúa en el -∞ del eje Y; y se hace coincidir el orden polar con el orden de las abscisas. Para construir el Cierre Inferior, se procede de manera similar a la anterior solo que la ordenación es de menor a mayor abscisa.

Fig. 3.3.1. Clasificación de puntos en Andrew.

3.4. LAS APROXIMACIONES AL CIERRE CONVEXO. Los algoritmos que vamos a estudiar buscan resolver el problema que supone no disponer del tiempo necesario para obtener un Cierre Convexo Exacto de una nube de puntos dada. Como solución a este problema el conjunto de algoritmos que veremos buscan obtener una aproximación al Cierre pero con un consumo de tiempo muy inferior al que se necesita para hallar el Cierre Exacto.

3.5. ALGORITMO k BANDAS POR DEFECTO (A.B.D.). Este algoritmo calcula el cierre convexo aproximado de una nube de puntos dada S.


- 9 -

La estrategia que usa este algoritmo para acelerar la obtención del cierre es reducir el número de puntos de la nube S a un subconjunto R, pequeño y representativo del cierre de S y trabajar con este subconjunto reducido de puntos para obtener el cierre sobre los mismos. La velocidad de este algoritmo depende del resultado buscado, con lo que es un algoritmo de salida sensitiva, esto es, a mayor número de bandas k el número de puntos del subconjunto R aumenta hasta un máximo de (2k+2); dos puntos por banda más dos puntos extremos, aumentando también el tiempo de obtención del resultado. Este algoritmo busca una aproximación por defecto al cierre, es decir, es una aproximación en la que pueden quedar algunos puntos de la nube S fuera de este cierre aproximado.

Fig. 3.5.1. Diferencia Cierre convexo y aproximado (ABD).

3.5.1. Descripción del algoritmo. El algoritmo comienza localizando los puntos extremos Izquierdo y Derecho de la nube de puntos e incluyendo estos en R. El espacio entre estos dos puntos extremos lo dividimos en k bandas verticales de igual tamaño, a continuación para cada una de las k bandas existentes obtenemos el punto más Bajo y más Alto de esa banda y los incluimos en nuestro subconjunto R de puntos representativos del cierre de la nube de puntos S. Una vez que hemos recorrido todas las bandas, en R obtendremos un conjunto de puntos sobre el que aplicaremos el algoritmo de Andrew obteniendo así el Cierre Aproximado de S.

3.5.2. Seudocódigo. Entrada: Un conjunto S de n puntos. Salida: Un conjunto C formado por los puntos vértice del cierre convexo aproximado por defecto. Paso 1: Izquierdo y Derecho = Obtención_puntos_izquierdoyderecho(S) Paso 2: Inclusión_en_ R(Izquierdo y Derecho) Paso 3: kBandas =DividimosEnkBandas (Izquierdo – Derecho) Paso 4: Para cada banda hasta k de kBandas

- Alto y Bajo =ObtenemosAltoYBajodelaBanda(banda)


- 10 -

- Inclusión_en_R(Alto y Bajo) Paso 5: C=Aplicamos_Andrew_sobre (R).

3.5.3. Complejidad. Veamos la complejidad de este algoritmo, en el Paso 1 hay que hacer una comparación entre todos los puntos n para saber cuales son los puntos extremos izquierdo y derecho por lo tanto es de O(n). En el Paso 2 hacemos una inserción con tiempo constante O(1). En el Paso 3 obtenemos k bandas para lo que necesitaremos un número k+1 de operaciones para hallar las fronteras de las bandas, por lo tanto complejidad O(k). En el Paso 4 se realizan dos operaciones por cada banda k y la complejidad de cada una de estas operaciones es O(n) para la búsqueda de los puntos Alto y Bajo y de O(1) para la inserción por lo tanto, la complejidad del Paso 4 es k*(O(n)+O(1)) resultando O(k n). El Paso 5 tiene una complejidad de O(k log k). Resumiendo: Paso 1: O(n) Paso 2: O(1) Paso 3: O(k) Paso 4: O(k n) Paso 5: O(k log k) Preproceso: Pasos 1,2,3,4 O(n). Obtención del cierre de los k puntos reducidos: Paso 5 O(k log k).

De esta forma resulta que al ser n mucho mayor que k la complejidad esperada de este algoritmo será de O(n) . Es decir el algoritmo se acelera considerablemente puesto que se pasa de trabajar con todos los puntos de S a sólo un pequeño subconjunto de este.


- 11 -

Fig. 3.5.2. Nube de puntos dato con distribución normal en un rectángulo.

Fig. 3.5.3. Puntos Extremos; Izquierdo y Derecho.


- 12 -

Fig. 3.5.4. Creación de 6 Bandas entre los puntos extremos.

Fig. 3.5.5. Puntos Alto y Bajo de cada una de las bandas que forman el subconjunto R seleccionado

por el ABD de la nube de puntos dato.


- 13 -

Fig. 3.5.6. División de Andrew en puntos Inferiores y Superiores.

Fig. 3.5.7. Ejemplo de giro a la izquierda en la aplicación del algoritmo de Graham (I).


- 14 -

Fig. 3.5.8. Ejemplo de giro a la izquierda en la aplicación del algoritmo de Graham (II). Punto

descartado del cierre.

Fig. 3.5.9. Resultado obtenido al aplicar Graham a una de las partes de la división hecha por

Andrew.


- 15 -


Andrew.

Fig. 3.5.11. Cierre Convexo Aproximado que resulta de la concatenación del Superior e Inferior.


- 16 -

Fig. 3.5.12. Cierre Aproximado obtenido con el algoritmo de Bandas por Defecto con 6 Bandas.

3.5.4. Error en la aproximación por defecto del algoritmo de bandas.

Veamos el error que se comete entre el Cierre Aproximado y el Cierre Exacto en una banda;

Fig. 3.5.13. Secuencia de pasos para intuir el error en ABD.

Fig. 3.5.13.a. Fig. 3.5.13.b.


- 17 -

Fig. 3.5.13.c. Fig. 3.5.13.d.

Fig. 3.5.13.e.

El mayor error se ve que esta determinado por el tamaño de la banda.

Donde: Pe punto del Cierre Exacto. Pa punto del Cierre Aproximado. k es el número de bandas. Xmax la coordenada X del punto más a la derecha de la nube (la mayor coordenada X). Xmin la coordenada X del punto más a la izquierda de la nube (la menor coordenada X).

Y por lo tanto a mayor k menor error.


- 18 -

3.6. ALGORITMO k BANDAS POR EXCESO (A.B.E.). Este algoritmo calcula el cierre convexo aproximado de una nube de puntos dada S.

La estrategia que usa este algoritmo para acelerar la obtención del cierre es el reducir el número de puntos de la nube S a un nuevo conjunto R de puntos, pequeño y representativo del cierre de S y trabajar con este nuevo conjunto reducido de puntos para obtener el cierre sobre los mismos. La velocidad de este algoritmo depende del resultado buscado, con lo que es un algoritmo de salida sensitiva, esto es, a mayor número de bandas k el número de puntos del nuevo conjunto R aumenta hasta un máximo de (2(k+1)+2); dos puntos por cada frontera o separación de banda más dos puntos extremos, aumentando también el tiempo de obtención del resultado.

En este algoritmo a diferencia del ABD en el nuevo conjunto R pueden surgir puntos que no estaban en la nube original S. Este algoritmo busca una aproximación por exceso al cierre es decir es una aproximación en la que nos asegura que todos los puntos de la nube S estarán en su interior.

Fig. 3.6.1. Diferencia Cierre Convexo y Aproximado (ABE).

3.6.1. Descripción del algoritmo. El algoritmo comienza localizando los puntos extremos Izquierdo y Derecho de la nube de puntos e incluyendo estos en R. El espacio entre estos dos puntos extremos lo dividimos en k bandas verticales de igual tamaño, a continuación para cada una de las k bandas existentes obtenemos el punto más Bajo y más Alto de esa banda, proyectamos estos dos puntos sobre las 2 líneas frontera de la banda obteniendo de esta forma cuatro nuevos puntos de los cuales añadimos el mas alto y mas bajo de cada frontera al nuevo conjunto R de puntos representativos del cierre de la nube de puntos S. Una vez que hemos recorrido todas las bandas, en R obtendremos un conjunto de puntos sobre el que aplicaremos el algoritmo de Andrew obteniendo así el cierre aproximado de S.


- 19 -

3.6.2. Seudocódigo. Entrada: Un conjunto S de n puntos. Salida: Un conjunto C formado por los puntos vértice del cierre convexo aproximado por exceso. Paso 1: Izquierdo y Derecho = Obtención_puntos_izquierdoyderecho(S) Paso 2: Inclusión_en_ R(Izquierdo y Derecho) Paso 3: kBandas =DividimosEnkBandas (Izquierdo – Derecho) Paso 4: Para cada banda hasta k de kBandas

- Alto y Bajo =ObtenemosAltoYBajodelaBanda(banda) - Punto_Proyección_Alto_sobre_frontera_izquierda(banda) - Punto_Proyección_Alto_sobre_frontera_derecha(banda) - Punto_Proyección_Bajo_sobre_frontera_izquierda(banda) - Punto_Proyección_Bajo_sobre_frontera_derecha(banda) - Inclusión_en_R(de mas Alto y Bajo en fronteraIzq.)

Paso 5: C=Aplicamos_Andrew_sobre (R).

3.6.3. Complejidad. Veamos la complejidad de este algoritmo, en el Paso 1 hay que hacer una comparación entre todos los puntos n para saber cuales son los puntos extremos izquierdo y derecho por lo tanto es de O(n). En el Paso 2 hacemos una inserción con tiempo constante O(1). En el Paso 3 obtenemos k bandas para lo que necesitaremos un número k+1 de operaciones para hallar las fronteras de las bandas, por lo tanto complejidad O(k). En el Paso 4 se realizan seis operaciones por cada banda k y la complejidad de cada una de estas operaciones es O(n) para la búsqueda de los puntos Alto y Bajo, O(1) para la obtención de los puntos proyectados sobre las fronteras y de O(1) para la inserción, por lo tanto, la complejidad del Paso 4 es k*(O(n)+O(1)) resultando O(k n). El Paso 5 tiene una complejidad de O(k log k). Resumiendo: Paso 1: O(n) Paso 2: O(1) Paso 3: O(k) Paso 4: O(k n) Paso 5: O(k log k) Preproceso: Pasos 1,2,3,4 O(n). Obtención del cierre de los k puntos reducidos: Paso 5 O(k log k).



- 20 -


Fig. 3.6.3. Puntos Extremos; Izquierdo y Derecho.


- 21 -

Fig. 3.6.4. Creación de 6 Bandas entre los puntos extremos.

Fig. 3.6.5. Puntos seleccionados por el ABE de la nube de puntos dato.


- 22 -




- 23 -


descartado del cierre


Andrew.


- 24 -


Andrew.



- 25 -

Fig. 3.6.12. Cierre Aproximado obtenido con el algoritmo de Bandas por Exceso con 6 Bandas.

3.6.4. Error en la aproximación por exceso del algoritmo de bandas.

Analizando lo que sucede en una banda vemos lo siguiente: Fig. 3.6.13. Secuencia de pasos para intuir el error en ABE.

Fig. 3.6.13.a. Fig. 3.6.13.b.

Fig. 3.6.13.c. Fig. 3.6.13.d.


- 26 -

Fig. 3.6.13.e.

Donde: Pe punto del Cierre exacto. Pa punto del Cierre aproximado. k es el número de bandas. Xmax la coordenada X del punto más a la derecha de la nube (la mayor coordenada X). Xmin la coordenada X del punto más a la izquierda de la nube (la menor coordenada X).

Por lo tanto a mayor k menor error.


- 27 -

3.7. ALGORITMO k X k CUADRÍCULAS POR DEFECTO (A.C.D). Este algoritmo calcula el cierre convexo aproximado de una nube de puntos dada S.

La estrategia que usa este algoritmo para acelerar la obtención del cierre es reducir el número de puntos de la nube S a un subconjunto R, pequeño y representativo del cierre de S y trabajar con este subconjunto reducido de puntos para obtener el cierre sobre los mismos. La velocidad de este algoritmo depende del resultado buscado, con lo que es un algoritmo de salida sensitiva, esto es, a mayor número de cuadrículas k*k el número de puntos del subconjunto R aumenta hasta un máximo de (k*k+4); un punto por cuadrícula más cuatro puntos extremos, aumentando también el tiempo de obtención del resultado. Este algoritmo busca una aproximación por defecto al cierre es decir es una aproximación en la que pueden quedar algunos puntos de la nube S fuera de este cierre aproximado.

3.7.1. Descripción del algoritmo. El algoritmo comienza localizando los puntos extremos Izquierdo, Derecho,

Superior e Inferior de la nube de puntos e incluyendo estos en R. El espacio entre los dos puntos extremos Izquierdo y Derecho lo dividimos en k bandas verticales de igual tamaño, y de forma análoga actuamos sobre los extremos Inferior y Superior pero dividiendo en k bandas horizontales, a continuación para cada una de las k*k cuadrículas existentes obtenemos un punto interior al solapamiento de ambas bandas y los incluimos en nuestro subconjunto R de puntos representativos del cierre de la nube de puntos S. Una vez que hemos recorrido todas las cuadrículas, en R obtendremos un conjunto de puntos sobre el que aplicaremos el algoritmo de Andrew obteniendo así el Cierre Aproximado de S.

3.7.2. Seudocódigo. Entrada: Un conjunto S de n puntos. Salida: Un conjunto C formado por los puntos vértices del cierre convexo aproximado por defecto. Paso 1: Izquierdo,Derecho,Inferior y Superior = Obtención_puntos_extremos(S) Paso 2: Inclusión_en_ R(Izquierdo,Derecho,Inferior y Superior) Paso 3: kBandasVerticales =DividimosEnkBandasVerticales (Izquierdo – Derecho) Paso 4: kBandasHorizontales =DividimosEnkBandasHorizontales (Inferior – Superior) Paso 5: Para cada bandaVertical hasta k de kBandasVerticales Para cada bandaHorizontal hasta k de kBandasHorizontales

- PuntoInteriorAmbasBandas=


- 28 -

ObtenemosInteriorCuadrícula(bandaVertical,bandaHorizontal) - Inclusión_en_R(PuntoInteriorAmbasBandas)


3.7.3. Complejidad.

Analicemos la complejidad de este algoritmo, en el Paso 1 hay que hacer una comparación entre todos los puntos n para saber cuales son los puntos extremos Izquierdo, Derecho, Inferior y Superior por lo tanto es de O(n). En el Paso 2 hacemos una inserción con tiempo constante O(1). En el Paso 3 y Paso 4 obtenemos k bandas para lo que necesitaremos un número k+1 de operaciones para hallar las fronteras de las bandas, por lo tanto complejidad O(k) en cada uno de los pasos. En el Paso 5 se realizan dos operaciones por cada cuadrícula y la complejidad esperada de cada una de estas operaciones es O(n/k*k) para la búsqueda de un punto interior, y de O(1) para la inserción, por lo tanto, la complejidad del Paso 5 es k*k*(O(n/(k*k))+O(1)) resultando O(n). El Paso 6 tiene una complejidad de O(k log k). Resumiendo: Paso 1: O(n) Paso 2: O(1) Paso 3: O(k) Paso 4: O(k) Paso 5: O(n) Paso 6: O(k log k) Preproceso: Pasos 1,2,3,4,5 O(n). Obtención del cierre de los k puntos reducidos: Paso 6 O(k log k).



- 29 -


Fig. 3.7.2. Puntos Extremos: Derecho, Izquierdo, Superior e Inferior.


- 30 -

Fig. 3.7.3. División en una cuadrícula de 6x6 entre los puntos extremos.

Fig. 3.7.4. Puntos seleccionados por el ACD de la nube de puntos dato.


- 31 -




- 32 -


descartado del cierre.


Andrew.


- 33 -


Andrew.



- 34 -

Fig. 3.7.11. Cierre Aproximado obtenido con el algoritmo de Cuadrículas por Defecto con 6x6.

3.7.4. Error en la aproximación por defecto en algoritmo de cuadrículas. Fig. 3.7.12. Secuencia de pasos para intuir el error en ACD.

Error máximo en una casilla:

Donde: Pe punto del Cierre exacto. Pa punto del Cierre aproximado. k es el número de bandas. Xmax la coordenada X del punto más a la derecha de la nube (la mayor coordenada X).


- 35 -

Xmin la coordenada X del punto más a la izquierda de la nube (la menor coordenada X). Ymax la coordenada Y del punto más alto de la nube (la mayor coordenada Y). Ymin la coordenada Y del punto más bajo de la nube (la menor coordenada Y).

Por lo tanto a mayor k menor error.


- 36 -

3.8. ALGORITMO k X k CUADRÍCULAS POR EXCESO (A.C.E.). Este algoritmo calcula el cierre convexo aproximado de una nube de puntos dada S.

La estrategia que usa este algoritmo para acelerar la obtención del cierre es reducir el número de puntos de la nube S a un nuevo conjunto R de puntos, pequeño y representativo del cierre de S y trabajar con este nuevo conjunto reducido de puntos para obtener el cierre sobre los mismos. La velocidad de este algoritmo depende del resultado buscado, con lo que es un algoritmo de salida sensitiva, esto es, a mayor número de cuadrículas k*k el número de puntos del nuevo conjunto R aumenta hasta un máximo de 4(k*k)+4; cuatro puntos por cada cuadrícula más los cuatro puntos extremos, aumentando también el tiempo de obtención del resultado.

En este algoritmo a diferencia del ACD en el nuevo conjunto R pueden surgir puntos que no estaban en la nube original S. Este algoritmo busca una aproximación por exceso al cierre es decir es una aproximación en la que nos asegura que todos los puntos de la nube S estarán en su interior.

3.8.1. Descripción del algoritmo.

El algoritmo comienza localizando los puntos extremos Izquierdo, Derecho, Superior e Inferior de la nube de puntos S e incluyendo estos en un nuevo conjunto R. El espacio entre los dos puntos extremos Izquierdo y Derecho lo dividimos en k bandas verticales de igual tamaño, y de forma análoga actuamos sobre los extremos Inferior y Superior pero dividiendo en k bandas horizontales, a continuación para cada una de las k*k cuadrículas existentes examinamos si existe un punto en su interior y si así es, obtenemos los cuatro puntos vértice del rectángulo que forman el cruce de las bandas y los incluimos en nuestro nuevo conjunto R de puntos representativos del cierre de la nube de puntos S. Una vez que hemos recorrido todas las cuadrículas, en R obtendremos un conjunto de puntos sobre el que aplicaremos el algoritmo de Andrew obteniendo así el cierre aproximado de S por exceso.

3.8.2. Seudocódigo. Entrada: Un conjunto S de n puntos. Salida: Un conjunto C formado por los puntos vértices del cierre convexo aproximado por exceso. Paso 1: Izquierdo,Derecho,Inferior y Superior = Obtención_puntos_extremos(S) Paso 2: Inclusión_en_ R(Izquierdo,Derecho,Inferior y Superior) Paso 3: kBandasVerticales =DividimosEnkBandasVerticales (Izquierdo – Derecho)


- 37 -

Paso 4: kBandasHorizontales =DividimosEnkBandasHorizontales (Inferior – Superior) Paso 5: Para cada bandaVertical hasta k de kBandasVerticales Para cada bandaHorizontal hasta k de kBandasHorizontales

- PuntosVerticeDelRectanguloFormadoPorAmbasBandas= ObtenemoVerticesCuadrícula(bandaVertical,bandaHorizontal) - Inclusión_en_R(PuntosVerticeDelRectangulo)


3.8.3. Complejidad.

Analicemos la complejidad de este algoritmo, en el Paso 1 hay que hacer una comparación entre todos los puntos n para saber cuales son los puntos extremos Izquierdo, Derecho, Inferior y Superior por lo tanto es de O(n). En el Paso 2 hacemos una inserción en tiempo constante O(1). En el Paso 3 y Paso 4 obtenemos k bandas para lo que necesitaremos un número k+1 de operaciones para hallar las fronteras de las bandas, por lo tanto complejidad O(k) en cada uno de los pasos. En el Paso 5 se realizan dos operaciones por cada cuadrícula y la complejidad esperada de cada una de estas operaciones es O(n/(k*k)) para la búsqueda de un punto interior y obtención de los cuatro vértices de la cuadrícula, y de O(1) para la inserción, por lo tanto, la complejidad del Paso 5 es k*k*(O(n/(k*k))+O(1)) resultando O(n). El Paso 6 tiene una complejidad de O(k log k). Resumiendo: Paso 1: O(n) Paso 2: O(1) Paso 3: O(k) Paso 4: O(k) Paso 5: O(n) Paso 6: O(k log k) Preproceso: Pasos 1,2,3,4,5 O(n). Obtención del cierre de los k puntos reducidos: Paso 6 O(k log k).



- 38 -




- 39 -

Fig. 3.8.3. División en una cuadrícula de 6x6 entre los puntos extremos.

Fig. 3.8.4. Puntos seleccionados por el ACE de la nube de puntos dato.


- 40 -




- 41 -


descartado del Cierre.


Andrew.


- 42 -


Andrew.



- 43 -

Fig. 3.8.11. Cierre Aproximado obtenido con el algoritmo de Cuadrículas por Exceso con 6x6.

3.8.4. Error en la aproximación por exceso del algoritmo de cuadrículas. Fig. 3.8.12. Secuencias de pasos para intuir el error en ACE.

Error máximo en una casilla:

Donde: Pe punto del cierre exacto. Pa punto del cierre aproximado. k es el número de bandas. Xmax la coordenada X del punto más a la derecha de la nube (la mayor coordenada X). Xmin la coordenada X del punto más a la izquierda de la nube (la menor coordenada X). Ymax la coordenada Y del punto más alto de la nube (la mayor coordenada Y).


- 44 -

Ymin la coordenada Y del punto más bajo de la nube (la menor coordenada Y). Por lo tanto a mayor k menor error.


- 45 -

3.9. ALGORITMO k RAYOS POR DEFECTO (A.R.D.). Este algoritmo calcula el cierre convexo aproximado de una nube de puntos dada S.

La estrategia que usa este algoritmo para acelerar la obtención del cierre es reducir el número de puntos de la nube S a un subconjunto R de puntos, pequeño y representativo del cierre de S y trabajar con este conjunto reducido de puntos para obtener el cierre sobre los mismos. La velocidad de este algoritmo depende del resultado buscado, con lo que es un algoritmo de salida sensitiva, esto es, a mayor número de rayos k el número de puntos del conjunto R aumenta hasta un máximo de (k+4); un punto por rayo, más cuatro puntos extremos, aumentando también el tiempo de obtención del resultado.

Este algoritmo busca una aproximación por defecto al cierre, es decir, es una aproximación en la que no podemos asegurar que todos los puntos de la nube S estarán en su interior.


El algoritmo comienza localizando los puntos extremos Izquierdo, Derecho, Superior e Inferior de la nube de puntos S e incluyendo estos en un subconjunto R. Con los cuatro puntos anteriores hallamos el centro de los mismos donde colocaremos el foco de los rayos de proyección. Una vez obtenido el foco se calcula el punto mas alejado en la dirección del rayo de proyección para cada uno de los k rayos, e insertaremos estos puntos en R. En R obtendremos un conjunto de puntos sobre el que aplicaremos el algoritmo de Andrew obteniendo así el cierre aproximado de S por defecto.

3.9.2. Seudocódigo. Entrada: Un conjunto S de n puntos. Salida: Un conjunto C formado por los puntos vértice del cierre convexo aproximado por defecto. Paso 1: Izquierdo,Derecho,Inferior y Superior = Obtención_puntos_extremos(S) Paso 2: Inclusión_en_ R(Izquierdo,Derecho,Inferior y Superior) Paso 3: kRayos =DividimosEnkRayos (360º) Paso 4: Para cada rayo hasta k de kRayos

- PuntoMásAlejadoSegúnRayo= ObtenemoPuntoMásAlejado(rayo) - Inclusión_en_R(PuntoMásAlejadoSegúnRayo)



- 46 -

3.9.3. Complejidad.

Analizando la complejidad de este algoritmo, tenemos que en el Paso 1 hay que hacer una comparación entre todos los puntos n para saber cuales son los puntos extremos Izquierdo, Derecho, Inferior y Superior por lo tanto es de O(n). En el Paso 2 hacemos una inserción con tiempo constante O(1). En el Paso 3 obtenemos k rayos para lo que necesitaremos un número k de operaciones para hallar los ángulos de los rayos, por lo tanto complejidad O(k). En el Paso 4 se realizan dos operaciones por cada rayo y la complejidad de cada una de estas operaciones es O(n) para la búsqueda del punto más alejado en sentido del rayo de proyección, y de O(1) para la inserción, por lo tanto, la complejidad del Paso 4 es k*( O(n)+O(1) ) resultando O(k n). El Paso 5, la aplicación de Andrew tiene una complejidad de O(k log k). Resumiendo: Paso 1: O(n) Paso 2: O(1) Paso 3: O(k) Paso 4: O(k n) Paso 5: O(k log k) Preproceso: Pasos 1,2,3,4, O(n). Obtención del cierre de los k puntos reducidos: Paso 5 O(k log k).




- 47 -


Fig. 3.9.3. Calculo del Foco del que partirán los rayos de proyección en el punto medio de los

extremos.


- 48 -

Fig. 3.9.4. Hallado punto más alejado de la nube en dirección del rayo de proyección.

Fig. 3.9.5. Puntos seleccionados por el ARD de la nube de puntos dato.


- 49 -



Andrew.


- 50 -


Andrew.



- 51 -

Fig. 3.9.10. Cierre Aproximado obtenido con el algoritmo de Rayos por Defecto con 9 rayos.

3.9.4. Error en la aproximación por defecto en algoritmo de rayos. Fig. 3.9.11. Secuencia de pasos para intuir el error en ARD.

Fig. 3.9.11.a.


- 52 -

Fig. 3.9.11.b.

Fig. 3.9.11.c.


- 53 -

Se ve claramente como el error depende de α y α=360º/k por lo tanto el error depende de k a mayor k menor error.


- 54 -

3.10. ALGORITMO k RAYOS POR EXCESO (A.R.E.). Este algoritmo calcula el cierre convexo aproximado de una nube de puntos dada

S. La estrategia que usa este algoritmo para acelerar la obtención del cierre es

reducir el número de puntos de la nube S a un nuevo conjunto R de puntos, pequeño y representativo del cierre de S y trabajar con este conjunto reducido de puntos para obtener el cierre sobre los mismos. La velocidad de este algoritmo depende del resultado buscado, con lo que es un algoritmo de salida sensitiva, esto es, a mayor número de rayos k el número de puntos del conjunto R aumenta hasta un máximo de (k+4); un punto por rayo, más cuatro puntos extremos, aumentando también el tiempo de obtención del resultado.

En este algoritmo a diferencia del ARD en el nuevo conjunto R pueden surgir puntos que no estaban en la nube original S.

Este algoritmo busca una aproximación por exceso al cierre es decir es una aproximación en la que podemos asegurar que todos los puntos de la nube S estarán en su interior.


El algoritmo comienza localizando los puntos extremos Izquierdo, Derecho, Superior e Inferior de la nube de puntos S e incluyendo estos en un nuevo conjunto R. Con los cuatro puntos anteriores hallamos el centro de los mismos donde colocaremos el foco de los rayos de proyección. Una vez obtenido el foco se calcula el punto más alejado en la dirección del rayo de proyección para cada uno de los k rayos, y calculamos la intersección de la recta perpendicular al rayo k y la recta perpendicular al rayo k+1, insertaremos estos puntos intersección en R. En R obtendremos un conjunto de puntos sobre el que aplicaremos el algoritmo de Andrew obteniendo así el cierre aproximado de S por exceso.

3.10.2. Seudocódigo. Entrada: Un conjunto S de n puntos. Salida: Un conjunto C formado por los puntos vértice del cierre convexo aproximado por exceso. Paso 1: Izquierdo,Derecho,Inferior y Superior = Obtención_puntos_extremos(S) Paso 2: Inclusión_en_ R(Izquierdo,Derecho,Inferior y Superior) Paso 3: kRayos =DividimosEnkRayos (360º) Paso 4: Para cada rayo hasta k de kRayos

- PuntoMásAlejadoSegunRayo= ObtenemoPuntoMásAlejado(rayo) - PuntoIntersección=IntersecciónPerpendiculares(k y k+1) - Inclusión_en_R(PuntoIntersección)



- 55 -

3.10.3. Complejidad. Analizando la complejidad de este algoritmo, tenemos que en el Paso 1 hay que hacer una comparación entre todos los puntos n para saber cuales son los puntos extremos Izquierdo, Derecho, Inferior y Superior por lo tanto es de O(n). En el Paso 2 hacemos una inserción con tiempo constante O(1). En el Paso 3 obtenemos k rayos para lo que necesitaremos un número k de operaciones para hallar los ángulos de los rayos, por lo tanto complejidad O(k). En el Paso 4 se realizan tres operaciones por cada rayo y la complejidad de cada una de estas operaciones es O(n) para la búsqueda del punto más alejado en sentido del rayo de proyección, una operación de cálculo para cada punto intersección O(1) y de O(1) para la inserción, por lo tanto, la complejidad del Paso 4 es k*( O(n)+O(1) ) resultando O(k n). El Paso 5, la aplicación de Andrew tiene una complejidad de O(k log k). Resumiendo: Paso 1: O(n) Paso 2: O(1) Paso 3: O(k) Paso 4: O(k n) Paso 5: O(k log k) Preproceso: Pasos 1,2,3,4, O(n). Obtención del cierre de los k puntos reducidos: Paso 5 O(k log k).

De esta forma resulta que al ser n mucho mayor que k la complejidad esperada de este algoritmo será de O(n). Es decir el algoritmo se acelera considerablemente puesto que se pasa de trabajar con todos los puntos de S a sólo un pequeño subconjunto de este. Veamos



- 56 -


Fig. 3.10.3. Cálculo del Foco del que partirán los rayos de proyección en el punto medio de los

extremos.


- 57 -

Fig. 3.10.4. Línea Perpendicular al primer Rayo que pasa por el punto más alejado en esa

dirección.

Fig. 3.10.5. Punto intersección de las líneas perpendiculares a los rayos 1º y 2º.


- 58 -

Fig. 3.10.6. Puntos seleccionados por el ARE con 9 rayos.



- 59 -


Andrew.


Andrew.


- 60 -


Fig. 3.10.11. Cierre Aproximado obtenido con el algoritmo de Rayos por Exceso con 9 rayos.


- 61 -

3.10.4. Error en la aproximación por exceso del algoritmo de rayos. Fig. 3.10.12. Secuencia de pasos para intuir el error en ARE.

Fig. 3.10.12.a.


- 62 -

Fig. 3.10.12.b.

Fig. 3.10.12.c.


- 63 -

Se ve claramente como el error depende de α y α=360º/k por lo tanto el error depende de k a mayor k menor error.


- 64 -

4. ANÁLISIS, DISEÑO E IMPLEMENTACIÓN.

4.1. ANÁLISIS. Comenzamos analizando las necesidades que debe cubrir nuestro programa, que aunque aquí aparezcan como una lista elaborada de una sola vez en realidad es el fruto de varias vueltas sobre las etapas de análisis de requisitos y la de diseño; Requisitos:

• El programa debe implementar seis algoritmos de Geometría Computacional (ABD, ABE, ACD, ACE, ARD, ARE) en modo paso a paso y con retroceso para permitir al usuario observar la ejecución de los mismos.

• Como la utilidad de estos algoritmos queda patente para una nube de puntos dato S muy grande, incorporaremos una opción de ejecución directa de los algoritmos hasta la solución sin tener que estar reiteradamente el usuario interactuando con la inferface para obtenerla.

• También debemos proporcionar una forma de ejecutar los algoritmos sin interrupciones para poder obtener el tiempo que este tarda en ejecutarse sobre una nube de datos S.

• Necesitaremos un área de dibujo sobre la que se muestren gráficamente como se van construyendo las soluciones de los algoritmos.

• Una ventana de texto flotante para mostrar textualmente lo que esta realizando el algoritmo en un momento dado.

• Un proceso de inserción de puntos sobre el área grafica directamente con el ratón.

• Un método de inserción de puntos por coordenadas para poder diseñar nuestra nube de puntos y poder analizar el comportamiento de los algoritmos sobre la misma.

• Evitaremos que el usuario tenga que crear a mano grandes cantidades de puntos para el estudio de los algoritmos implementando algún método de inserción de puntos aleatorios.

• Los algoritmos están pensados para reducir el tiempo en obtener el cierre aproximado de grandes nubes de puntos con lo que para facilitar la inserción de dicha nube se proveerá de una opción para tomar los datos desde un fichero y otra para guardar la nube en un fichero.

• También habrá que incorporar un manual de usuario para facilitar el uso de la aplicación.


- 65 -

4.2. DISEÑO E IMPLEMENTACIÓN.

Con el fin de obtener una solución lo más portable y accesible posible se decide programar la solución en Java y publicar una pagina web que soporte un applet de la aplicación, de esta forma se facilitara el acceso vía Internet a la misma, cumpliendo así con dichos requisitos del objetivo planteado.

El manual de usuario también se elaborará sobre páginas HTML para facilitar el acceso al mismo a los usuarios antes incluso de obtener el programa o su ejecución Applet. Este manual servirá además como una guía de uso del programa. Para permitir que la aplicación se pueda ejecutar por igual llamada como Applet desde un navegador o llamada como una aplicación Java usaremos la siguiente estructura:

Fig. 4.2.1. Diagrama de clases para homogeneizar el acceso a la aplicación.

La clase Cierre tiene como única finalidad crear el artificio necesario para que la clase Aplicación se ejecute de igual forma independientemente desde donde sea ejecutada. (Desde un navegador como un applet o desde el S.O. como un programa Java.). El código de la clase Aplicación será el mismo independientemente desde donde se ejecute la aplicación. Según se observa en los requisitos conviene implementar dos versiones de cada uno de los algoritmos; una que permita ejecutar los algoritmos en modo paso a paso y con opción de retroceso para ir deshaciendo las operaciones realizadas por los mismos y una segunda versión de los algoritmos que se ejecutaran de forma directa obteniendo las soluciones de un solo paso y sin posibilidad de deshacer las operaciones parciales.


- 66 -

Para el diseño de las dos versiones de los algoritmos usaremos una clase común a ambos que facilita dos cosas sobre los algoritmos; por un lado proporciona lo necesario para ejecutar los algoritmos paso a paso y por otro facilita la ejecución en Threads o hilos de ejecución que nos permitirán parar los algoritmos una vez que se encuentren en ejecución en avance automático.

Fig. 4.2.2. Diagrama de clases de la relación de generalización de los algoritmos.

El objeto FabricaAlgoritmos fabricará el objeto Algoritmo del tipo solicitado por el usuario. Es decir la clase FabricaAlgoritmos tiene un comportamiento de fábrica de objetos de doce tipos diferentes, un tipo de objeto por cada algoritmo implementado.

Con el fin de poder implementar el deshacer o vuelta atrás de los algoritmos se ha decidido diferenciar cada uno de los pasos de los algoritmos y usar diferentes esquemas según la complejidad del paso en cuestión:

• Objetos que representan un paso simple y con bajo coste en la realización de su “deshacer”. Es decir es el caso en los que se prefiere que el objeto realice una operación de deshacer sobre el conjunto de datos.


- 67 -

• Objetos que representan o almacenan el estado actual dentro de una secuencia de pasos y que tienen un comportamiento de máquina de estados.

• Objetos que tiene el comportamiento del patrón de diseño Memento (Recuerdo) que permite volver a estados anteriores sin tener que realizar operaciones deshacer. Relación Controlador – Originator - Memento.

Fig. 4.2.3. Diagrama de clases para permitir volver a estados anteriores.

La clase PasoGrahamSegAceptados realiza el rol de controlador, ListaCircular implementa el rol Originator del Patrón Memento quedando el rol Memento en MementoListaCircular.

• Implementación del patrón State en el que cada paso del algoritmo se representa como un estado distinto con un comportamiento distinto del algoritmo.

Para que el usuario pueda introducir puntos con valores más concretos con el ratón implementamos unas reglas gráficas en sus laterales:

Fig. 4.2.4. Diagrama de clases de las reglas gráficas.

Para representar la gran variedad de tipo de puntos de la aplicación usaremos una especialización por herencia:


- 68 -

Fig. 4.2.5. Especialización de Puntos por herencia.

Uso de un esquema productor consumidor para controlar y forzar la visualización del dibujo después de cada paso hacia delante o hacia atrás con hilos de ejecución.

4.3. OPTIMIZACIÓN DEL DISEÑO CON PATRONES.

4.3.1. Definición de patrón. En el diseño de software como en el diseño en general existen situaciones y problemas que se repiten una y otra vez. A estos problemas ya se les ha dado solución en otras ocasiones y el patrón trata de aprovechar esa experiencia y trabajo para otros diseños. Según diferentes autores; "Cada patrón describe un problema que ocurre una y otra vez en nuestro entorno, para describir después el núcleo de la solución a ese problema, de tal manera que esa solución pueda ser usada más de un millón de veces sin hacerlo siquiera dos veces de la misma forma"

Christopher Alexander “Un Patrón de diseño nomina, abstrae e identifica los aspectos claves de una estructura de diseño común, lo que los hace útiles para crear un diseño orientado a objetos reutilizable. El patrón de diseño identifica las clases e instancias participantes, sus roles y colaboraciones, y la distribución de responsabilidades. Cada patrón de diseño se centra en un problema concreto, describiendo cuando aplicarlo y si tiene sentido hacerlo teniendo otras restricciones de diseño, así como las consecuencias y las ventajas e inconvenientes de su uso. Por otro lado, como normalmente tendremos que implementar


- 69 -

nuestros diseños, un patrón también proporciona código de ejemplo en C++, y a veces en Smalltalk, para ilustrar una implementación.”

GoF.

4.3.2. Descripción de un patrón. La descripción de un patrón se puede realizar de muy diversas formas según diferentes autores pero en este caso usaremos los elementos de descripción propuesto por GoF.

• Nombre del patrón: debe tratar de tener un significado relacionado con él. • Clasificación o tipo: aunque no existe una clasificación formal se suelen

clasificar en patrones de creación, de estructura, y de comportamiento. • Propósito: Resume en una frase el problema que resuelve el patrón y qué

hace para resolverlo. • Motivación: describe el escenario que ilustra el problema de diseño y como

las estructuras de clases y objetos del patrón resuelven el problema. • Aplicabilidad: situaciones en las que el patrón seria útil. • Estructura: se representa gráficamente los elementos que constituyen el

patrón y sus relaciones. • Participantes: especificación de clases y objetos que intervienen en el patrón

y sus responsabilidades. • Colaboraciones: como interaccionan los participantes para cumplir con sus

responsabilidades. • Consecuencias: ventajas e inconvenientes que conlleva usar el patrón. • Usos conocidos: ejemplos donde se ha usado el patrón • Patrones relacionados: otros patrones en los que interviene o con los que

podría ser utilizado.

4.3.3. Patrón Factory Method (SeleccionAlgoritmoCommand - AlgoritmoEnPasosYenHilos).

• Nombre del patrón: Factory Method. • Clasificación o tipo: patrón de creación. • Propósito: devuelve una instancia de múltiples tipos de objetos, que

normalmente provienen de una misma superclase y las diferencias entre ellos son pequeños cambios en su comportamiento. La elección del tipo de objeto que finalmente se instancia corresponde a las subclases.

• Motivación: se desea desacoplar la interface grafica de uso de los algoritmos de los propios algoritmos. El patrón resuelve este desacoplamiento creando un interface común a todos los algoritmos y dejando que se cree el algoritmo adecuado en cada caso.

• Aplicabilidad: una clase no puede anticipar la clase de objetos que creará. • Estructura: se representa gráficamente los elementos que constituyen el

patrón y sus relaciones.


- 70 -

Fig. 4.3.1. Diagrama de clases del patrón Factory Method.

• Participantes:

o ABDP, ..., AREP, ABDD, ..., ARED, son las clases especificas de los algoritmos o productos en el patrón que serán devueltos por la fábrica.

o AlgoritmoEnPasosYenHilos, es la superclase común a los algoritmos o productos.

o IAlgoritmoEnPasosYenHilos, es la interface de objetos algoritmos o productos que crea la Fabrica-Aplicación.

o FabricaAlgortimos, es la encargada de crear el objeto en cuestión. o SeleccionAlgoritmoCommandConcrete, es la clase que selecciona el

tipo de algoritmo o producto concreto que se instancia.

• Colaboraciones: FabricaAlgoritmos usa un constructor de las subclases Algoritmos o productos eligiendo esa subclase según un parámetro tipo.

• Consecuencias: Elimina la necesidad de crear clases específicas para

manejar cada tipo de algoritmo o producto, haciendo más sencillo y flexible el manejo de nuevos tipos de algoritmos o productos.

4.3.4. Patrón State (AlgoritmoEnPasos -EstadosPaso).

• Nombre del patrón: State. • Clasificación o tipo: patrón de comportamiento. • Propósito: obtener diferentes comportamientos de un objeto en función de su

estado interno, con cada estado interno el objeto se comporta como si se tratara de otro objeto distinto.

• Motivación: se desea controlar el estado de los algoritmos implementados en su modo paso a paso y con retroceso. Para llevar a cabo este control de su estado interno y con él su comportamiento asociado, se recurre a crear una clase por cada estado interno, y a que dicha clase implemente un interface común llamado IEstadoAlgoritmo.


- 71 -

• Aplicabilidad: cuando un objeto deba cambiar su comportamiento en función de los cambios de estado que este sufra en tiempo de ejecución.

• Estructura: se representa gráficamente los elementos que constituyen el patrón y sus relaciones.

Fig. 4.3.2. Diagrama de clases del patrón State.

• Participantes:

o ABDP, es la clase que define el interface para los clientes de dicho algoritmo y contiene una referencia a la clase que especifica el estado en el que se encuentra actualmente el algoritmo.

o IEstadoAlgoritmo, es la interface común de las clases que representan los estados del objeto ABDP.

o PuntosAlejadosHEstado, BarrasVerticalesEstado, ..., MensajeFinalEstado, son las clases que representan los estados concretos del objeto ABDP.

• Colaboraciones: ABDP delega en el estado concreto actual la ejecución de

sus servicios o respuestas. Cada estado concreto sabe que estado le sucede y cual le precede.

• Consecuencias: Permite encapsular la lógica de un paso de los algoritmos en

una sola clase, mejorando la posibilidad de añadir o modificar el algoritmo con nuevos pasos más detallados. Se crea la transición de estados de forma explícita facilitando la claridad de la misma.

4.3.5. Patrón Composite (ElementoGrafico - Compuesto).

• Nombre del patrón: Composite. • Clasificación o tipo: patrón estructural. • Propósito: permite que el cliente use de forma homogénea tanto una

estructura simple (elemento o componente) como una estructura compleja (compuesto de elementos) sin tener que crear operaciones especiales distinguiendo el caso en el que se está.


- 72 -

• Motivación: se trata de simplificar las operaciones gráficas que se realizan creando una interface uniforme a todos los elementos gráficos sean objetos simples o una composición de ellos.

• Aplicabilidad: el cliente no conoce como se dibujan los elementos ni si estos son simples objetos o una composición de objetos.

• Estructura: se representa gráficamente los elementos que constituyen el


Fig. 4.3.3. Diagrama de clases del patrón Composite.

• Participantes:

o ZonaGrafica, es la clase cliente del patrón que desea tener una visión uniforme de los elementos gráficos. Trabaja con la estructura a través de la clase Elemento.

o Elemento o Componente, es la superclase común al resto de objetos gráficos incluidos los compuestos y define la interface común de la estructura.

o Punto, Segmento, Barra, Flecha, son clases hoja dentro del patrón y corresponden a elementos simples o finales.

o Compuesto, es la clase encargada de representar los objetos compuestos, formados de otros objetos simples y/o de otros objetos complejos recursivamente.

• Colaboraciones: ZonaGrafica como cliente usa siempre las operaciones sobre la clase Elemento de forma uniforme sin preocuparse por saber si el objeto en cuestión es un compuesto o no. Cuando se necesita un objeto compuesto se usa la clase Compuesto y cuando se necesita un elemento simple se usa una de las clases hoja del patrón.


- 73 -

• Consecuencias: Elimina la necesidad de crear clases especificas para cada tipo de composición o alternativa que se pueda dar, permitiendo dar cabida a cualquier combinación de elementos complejos en una estructura simple.

4.3.6. Patrón Observer (Papel – ZonaGrafica).

• Nombre del patrón: Observer. • Clasificación o tipo: patrón de comportamiento. • Propósito: Define una dependencia de uno-a-muchos entre objetos, de forma

que cuando un objeto cambia de estado se lo notifica a todos los objetos que dependen de él para que se actualicen si así lo consideran necesario. En este caso de aplicación la dependencia es una a uno entre la clase Papel y la clase Dibujo.

• Motivación: Muchos objetos deben ser informados por otros de un cambio en estos últimos para que puedan ellos también actualizarse en consecuencia. Un ejemplo claro de esto se encuentra en la visualización gráfica de objetos que deben cambiar si el objeto cambia.

• Aplicabilidad: o Cuando un objeto se desea que notifique sus cambios a otros pero no

se desea que se acoplen entre ellos. o Cuando un cambio en un objeto necesita informarse a otros, pero se

desconoce a priori su número.


Fig. 4.3.4. Diagrama de clases del patrón Observer.


- 74 -

• Participantes: especificación de clases y objetos que intervienen en el patrón y sus responsabilidades:

o ISubject es la interface con la definición de los métodos necesarios para el control de los Observers, es decir, para su registro como observadores y su eliminación una vez pierdan el interés en el objeto Subject.

o IObserver es la interface para los objetos que deseen ser observadores de objetos Subject.

o ConcreteSubject representan los objetos o datos a observar y son los encargados de notificar sus cambios.

o ConcreteObserver, son las clases que reciben las notificaciones de los cambios que sufren los objetos observados Subject.

• Colaboraciones: las clases ConcreteObserver se registran como observadores con un método publico de ConcreteSubject . Tras un cambio de estado de ConcreteSubject este usa un método propio notify que se encarga de notificar a todos los ConcreteObservers registrados sobre él.

• Consecuencias: o Este patrón permite a un objeto enviar notificaciones a otros objetos

sin que los objetos emisores o receptores sean conscientes de las clases a las que pertenecen.

o Podemos encontrar problemas con este patrón en casos en los que el tiempo que tarda en hacerse la notificación sea mayor del esperado debido por ejemplo a que exista un gran número de observadores o bien a que se realice una notificación en cascada de unos objetos a otros o incluso que se lleguen a dar ciclos sobre las notificaciones.

4.3.7. Patrón Builder (AplicacionCliente - DirectorIU - BuilderIU - IU).

• Nombre del patrón: Builder. • Clasificación o tipo: patrón de creación. • Propósito: permite ocultar las complejidades de la creación del objeto IU a

AplicacionCliente. • Motivación: se trata de simplificar la operación de creación del IU mediante

el encargo de dicha creación al BuilderIU y el control del DirectorIU. • Aplicabilidad: el algoritmo para la creación del objeto complejo debe ser

independiente de cómo se ensamblen las partes y de qué se compongan estas. • Estructura: se representa gráficamente los elementos que constituyen el



- 75 -

Fig. 4.3.5. Diagrama de clases del patrón Builder.

• Participantes:

o AplicacionCliente, es la clase cliente del patrón a la que se desea ocultar la creación del objeto complejo.

o Builder, es la superclase común a los objetos constructores y define la interface común de estos.

o BuilderIU, es una de las clases constructoras concretas del patrón y es la que se encarga de construir la IU producto del patrón a partir de las diferentes partes que lo componen.

o IU, es la clase producto del patrón y contendrá el objeto complejo. o DirectorIU, es la clase encargada de controlar en que orden se crean

las partes del objeto complejo.

• Colaboraciones: AplicacionCliente crea DirectorIU y lo configura con el constructor BuilderIU. El DirectorIU determina cuándo se debe crear una parte del objeto resultante y BuilderIU la construye. La AplicacionCliente finalmente obtiene el objeto resultante del constructor BuilderIU.

• Consecuencias: Se suprime la necesidad de que el cliente del patrón conozca la complejidad de la formación del producto IU. Se mejora el control sobre la creación detallada de las partes.

4.3.8. Patrón Command (AplicacionCliente–Llamador-CommandConcrete).

• Nombre del patrón: Command. • Clasificación o tipo: patrón de comportamiento. • Propósito: encapsular operaciones o métodos en objetos para poderlos usar

como parámetros en otros objetos, almacenar dichas operaciones para poder rehacer o deshacer más tarde las mismas.

• Motivación: se desea independizar las acciones que realiza el programa de los interfaces gráficos que los lanzan. El patrón resuelve esto creando un objeto para cada acción independiente de la interface gráfica.


- 76 -

• Aplicabilidad: el cliente no necesita saber quién ni cómo se ejecutará una acción determinada.


Fig. 4.3.6. Diagrama de clases del patrón Command.

• Participantes:

o AplicacionCliente, es la clase cliente del patrón se encarga de crear la acción concreta y de identificar que clase la recibirá.

o ICommand, es la superclase común a las acciones y define el interface de ejecución de las mismas.

o Llamador, es el encargado de almacenar las acciones concretas y de invocarlas cuando se necesitan.

o AbrirCommandConcrete, InsertarPuntoCommandConcrete, ... , son las clases que corresponden a las acciones propiamente dichas e implementan las acciones con llamadas a operaciones sobre los receptores.

o DocumentoReceptor, es la clase que se encarga de realizar las operaciones concretas solicitadas por los comandos o acciones.

• Colaboraciones: Llamador, es el objeto encargado de invocar el comando o

acción concreta a realizar, el CommandConcrete se ejecuta usando las operaciones de los receptores asociados por la AplicacionCliente en la creación de dichos Comandos.

• Consecuencias: se desacopla el objeto que solicita la acción del que sabe

como ejecutarla. Permite ampliar el número de acciones o comandos de forma sencilla sin tener que modificar las clases existentes.


- 77 -

5. VISIÓN GENERAL DEL “PRODUCTO”.

Haremos un recorrido por las opciones y características más importantes del programa desarrollado y de la web que le da soporte con el fin de tener una visión general del mismo.

5.1. ACCEDIENDO A LA APLICACIÓN. Para el acceso a la aplicación se cuenta con una pagina web que describe el entorno en los que trabaja la aplicación y sus requisitos tanto para acceder a ella como para su ejecución.

Fig. 5.1.1. Captura de la página de entrada de la web.

Desde estas páginas HTML se puede bien ejecutar directamente la aplicación desde un Applet de la propia página o bien se puede realizar una descarga del fichero aplicación para su posterior ejecución en una shell del propio sistema operativo y la Máquina Virtual Java.


- 78 -

Fig. 5.1.2. Esquema de las dos formas de ejecución de la aplicación.

Las principales diferencias prácticas para el usuario entre las dos formas de acceso son:

Ventajas Inconvenientes

Applet No necesita instalación por parte del usuario sirve cualquier

navegador que soporte Java y lo tenga activo y sobre cualquier sistema operativo o máquina.

Cada vez que se desee ejecutar la aplicación

debemos acceder a la Web. Hay partes de código que

por seguridad el navegador no deja ejecutar (para evitar

virus). Descarga Aplicación Se puede ejecutar cuantas veces

se desee sin necesidad de conectarse a la Web.

El usuario debe tener acceso a un lugar de

almacenamiento (disco). Tabla 5.1. Modo de ejecución Aplicación Java vs. Applet.

Como ya se comentó en el diseño la aplicación presentará el mismo aspecto externo para el usuario tanto si se ejecuta en modo Applet como si se ejecuta en modo Aplicación y la única variación entre los dos modos lo representa la restricción de algunos navegadores a no ejecutar en el modo Applet las operaciones sobre archivos que tiene el programa y que en modo Aplicación si están operativas.


- 79 -

Fig. 5.1.3. Captura de la interface gráfica de la aplicación.

5.2. INTRODUCIENDO NUESTRO PROBLEMA EN LA APLICACIÓN. El problema que aborda los algoritmos del cierre convexo aproximado es el tener que obtener una solución del cierre de una gran nube de puntos de forma rápida y éste es también el tipo de problemas que resuelve esta aplicación con la implementación de dichos algoritmos. Existen diversas formas de introducir los datos de nuestro problema o nube de puntos en el programa:

- Mediante la lectura de un fichero de datos con un formato específico. - Con el ratón sobre la zona de dibujo. - Introduciendo las coordenadas de cada punto manualmente. - O bien tenemos una opción que genera automáticamente puntos

aleatorios. • Lectura de Fichero. Una de las formas más cómodas de insertar los puntos dato de la

nube de puntos es con la opción del menú Archivo Abrir con la que podemos seleccionar un archivo que contiene los puntos y se insertan en la zona de dibujo automáticamente. Asociada también a esta operación existe la opción Archivo Guardar o Archivo Guardar Como que permiten almacenar los puntos de la nube de datos que se encuentra en ese momento en la zona de dibujo para su posterior utilización.


- 80 -

Fig. 5.2.1. Captura marco de interface Abrir-Archivo.

La especificación del formato de los ficheros es muy sencilla puesto que los únicos datos que contienen son puntos en dos dimensiones; Un punto viene representado por sus coordenadas X e Y. Con lo que el fichero contendrá dos pares de enteros por cada punto con formato predefinido de 32 bits. Ejemplo: Fichero con dos puntos. Punto 1 con X1,Y1 Punto 2 con X2,Y2 el fichero seria: EnteroX1_32bitsEnteroY1_32bits EnteroX2_32bitsEnteroY2_32bits

• Inserción con Ratón. Una forma de crear una nube con ciertas características visuales

es ésta, es decir, permite insertar puntos de forma visual sin tener en cuenta un gran grado de precisión en las coordenadas pero a cambio permite un gran control visual.

La forma de operar es la siguiente: colocamos el ratón sobre la zona de dibujo (área blanca) podremos ver como aparecen dos líneas una vertical y otra horizontal que van marcando sobre las reglas azules la posición actual del ratón y una vez situados en el lugar deseado hacemos un clic de ratón para insertar el punto en esa posición.


- 81 -

Fig. 5.2.2. Imagen de la inserción de un punto con ratón.

• Inserción por coordenadas. Con este método manual de inserción podemos insertar

los puntos con la precisión deseada dentro de la nube de puntos.

La forma de operar es colocándose sobre el cuadro de la casilla X, introducir el valor correspondiente y, a continuación, proceder sobre el cuadro de la casilla Y, una vez introducidos los valores pulsar sobre el botón Insertar.

Fig. 5.2.3. Imagen de la inserción de un punto por sus coordenadas.

• Puntos Aleatorios. Con esta opción se le pide al programa que genere un

determinado número de puntos aleatorios sobre la pantalla. Para realizar esta operación basta con insertar el valor del número de puntos que deseamos sobre la casilla Num y pulsar a continuación el botón Ptos. Aleatorios para que el programa genere dichos puntos.


- 82 -

Fig. 5.2.4. Imagen de inserción de puntos aleatorios.

Fig. 5.2.5. Ejemplo de una nube de puntos generada de forma aleatoria por el programa.

5.3. OBSERVANDO LA CONSTRUCCIÓN DE LA SOLUCIÓN. Cuando terminamos de insertar los puntos de nuestra nube de datos podemos proceder a ejecutar los algoritmos de forma controlada para obtener el cierre aproximado. Lo primero que debemos hacer es seleccionar el algoritmo que deseamos que el programa ejecute sobre nuestros datos, para ello acudiremos al menú de ejecución en pasos. Una vez elegido el algoritmo a usar ya podremos ponerlo en marcha con los botones de control de ejecución:


- 83 -

Fig. 5.3.1. Botones de control de ejecución de los algoritmos geométricos.

Con estos controles podemos hacer que el algoritmo tenga el siguiente comportamiento:

Indicamos al programa que debe ir deshaciendo operaciones hechas por el algoritmo hasta llegar a tener de nuevo la nube de puntos dato. Las operaciones se deshacen paso a paso y con un intervalo de tiempo entre cada una de ellas para poder ver el resultado de la operación.

Hacemos que el algoritmo de un solo paso hacia atrás y muestre el resultado sin ese paso.

Detiene la ejecución del algoritmo en el paso actual. Permitiendo continuar más tarde desde ese mismo paso.

Hacemos que el algoritmo de un solo paso hacia delante, y muestre el resultado de ese paso.

Le decimos al programa que comience a dar pasos hacia delante con un intervalo de tiempo entre paso y paso para ver la operación realizada. El algoritmo parará cuando obtenga el cierre aproximado.


- 84 -

Fig. 5.3.2. Tres pasos de la ejecución del ABD.

Como se puede observar en la ilustración que representan tres pasos consecutivos sobre una pequeña nube de puntos, los diversos puntos significativos o que forman parte de la construcción hacia la solución se marcan de forma diferente. Leyenda de elementos de construcción del cierre aproximado:

Punto dato.

Punto límite.

Punto construcción.

Punto al lado inferior de la recta. Punto al lado superior de la recta.

Foco

Punto candidato a Cierre Aproximado

Punto vértice perteneciente al Cierre Aproximado

Punto lista inferior Punto lista superior

Flecha de dirección de rayo.

Segmento candidato a formar parte del Cierre Aproximado.

Línea de construcción.

Línea del Cierre Aproximado.

Recta negra marcada por el algoritmo de Andrew. Tabla 5.3. Leyenda de elementos de construcción del cierre aproximado.


- 85 -

5.4. COMPARANDO QUÉ ALGORITMO ES MÁS RÁPIDO. Para poder realizar una comparación en tiempo real de la ejecución de los algoritmos el programa provee directamente una opción que lo hace de forma gráfica por nosotros. El programa lleva a cabo esta gráfica de la siguiente manera;

• Primero genera una nube de puntos aleatorios de tamaño 10x. • Sobre la nube anterior se ejecutan cada uno de los algoritmos de forma

secuencial y midiendo el tiempo que tarda el ordenador en generar la solución con cada uno de ellos.

• Posteriormente se vuelven a generar otras nubes cada vez con más puntos y se repiten las mediciones.


- 86 -

Fig. 5.4.1. Gráfica de tiempos para una ejecución real de los 6 algoritmos.

Lo primero que se puede observar en la gráfica es como con nubes de puntos

pequeñas la diferencia de comportamiento de los algoritmos es insignificante y es cuando va aumentado el número de puntos cuando las diferencias entre las tres familias de algoritmos se acentúan.

Se puede ver a simple vista como los algoritmos de Bandas son los más rápidos y tienen un mejor comportamiento frente al aumento del número de puntos en la nube.

Los siguientes en el ranking son los algoritmos de Cuadrículas que se ven más afectados por el aumento del número de puntos en la nube.

Finalmente los algoritmos más lentos son los algoritmos de Rayos que además se aprecia una pequeña diferencia de tiempos entre ellos a favor del A.R.D.

Los motivos por lo que estas diferencias son así son los siguientes: El mayor coste en tiempo de cada uno de los algoritmos lo representa el cálculo

del Cierre convexo del conjunto de puntos que los algoritmos preseleccionan, y a los


- 87 -

que finalmente aplicamos el Algoritmo de Andrew. Con este algoritmo a mayor número de puntos mayor tiempo en obtener la solución (n log n). De esta forma los objetivos de estos algoritmos son dos: reducir el número de puntos preseleccionados y obtener estos en el menor tiempo posible.

Sobre una nube de n puntos y un parámetro k.

Nº. Máximo puntos preseleccionados

Tiempo en obtener puntos preseleccionados

A.B.D 2k+2 Una pasada a n para obtener el tamaño banda. Una pasada a n para obtener los puntos. =2n

A.B.E 2(k+1)=2k+2 Una pasada a n para obtener el tamaño banda. Una pasada a n para obtener los puntos. =2n

A.C.D. (kxk)+4 Una pasada a n para obtener el tamaño bandas. kxk pasadas a n/kxk para obtener puntos (suponiendo distribución proporcional). =2n

A.C.E. 4(kxk)+4 Una pasada a n para obtener el tamaño bandas. kxk pasadas a n/kxk para obtener puntos (suponiendo distribución proporcional). =2n

A.R.D. k+4 Una pasada a n para obtener el foco. Una pasada a n para obtener punto en rayo 1. Una pasada a n para obtener punto en rayo 2. ... Una pasada a n para obtener punto en rayo k. =(k+1)n

A.R.E. k+4 Una pasada a n para obtener el foco. Una pasada a n para obtener punto en rayo 1. Una pasada a n para obtener


- 88 -

punto en rayo 2. ... Una pasada a n para obtener punto en rayo k. =(k+1)n

Tabla 5.4.Resumen de tiempos de los algoritmos

6. CONCLUSIONES.

6.1. LÍNEAS FUTURAS. Se puede reutilizar la interface gráfica de esta aplicación y sus componentes de construcción para aumentar el número de algoritmos de Geometría Computacional que lo usen de una forma simple.

La aplicación se podría ampliar con un mayor control sobre la visualización de los objetos y elementos auxiliares de construcción de los algoritmos.

También se podría calcular el error que supone la aproximación al cierre respecto del cierre exacto.

Otra mejora sobre la aplicación seria dar la opción de guardar las soluciones sobre ficheros para su posterior visión en una estructura gráfica de capas superpuestas.


- 89 -

7. ACRÓNIMOS. A.B.D. Algoritmo Bandas por Defecto. A.B.D.P. Algoritmo Bandas por Defecto en modo Paso a Paso A.B.D.D.. Algoritmo Bandas por Defecto en modo ejecución Directa. A.B.E. Algoritmo Bandas por Exceso. A.B.E.P. Algoritmo Bandas por Exceso en modo Paso a Paso. A.B.E.D. Algoritmo Bandas por Exceso en modo ejecución Directa. A.C.D. Algoritmo Cuadrículas por Defecto. A.C.D.P. Algoritmo Cuadrículas por Defecto en modo Paso a Paso. A.C.D.D. Algoritmo Cuadrículas por Defecto en modo ejecución Directa. A.C.E. Algoritmo Cuadrículas por Exceso. A.C.E.P. Algoritmo Cuadrículas por Exceso en modo Paso a Paso. A.C.E.D Algoritmo Cuadrículas por Exceso en modo ejecución Directa. A.R.D. Algoritmo Rayos por Defecto. A.R.D.P. Algoritmo Rayos por Defecto en modo Paso a Paso. A.R.D. D. Algoritmo Rayos por Defecto en modo ejecución Directa. A.R.E. Algoritmo Rayos por Exceso. A.R.E.P. Algoritmo Rayos por Exceso en modo Paso a Paso. A.R.E.D. Algoritmo Rayos por Exceso en modo ejecución Directa. GoF Gang-Of-Four – La banda de los cuatro que son: Erich Gamma,

Richard Helm, Ralph Johnson, and John Vlissides, HTML HyperText Markup Language – El lenguaje de marcas de hipertexto. UML Unified Modeling Language - Lenguaje Unificado de Modelado WWW

World Wide Web


- 90 -

8. TABLAS Y FIGURAS. Número. Descripción de la misma. Pagina. Tabla 5.1. Modo de ejecución Aplicación Java vs. Applet. 78 Tabla 5.3. Leyenda de elementos de construcción del cierre aproximado. 84 Tabla 5.4. Resumen de tiempos de los algoritmos 87 Número. Descripción de la misma. Pagina. Fig. 3.1.1. Definición intuitiva de Cierre convexo. 6 Fig. 3.2.1. Ordenación de puntos para el scan de Graham. 7 Fig. 3.3.1. Clasificación de puntos en Andrew. 8 Fig. 3.5.1. Diferencia Cierre convexo y aproximado (ABD). 9 Fig. 3.5.2. Nube de puntos dato con distribución normal en un rectángulo. 11 Fig. 3.5.3. Puntos Extremos; Izquierdo y Derecho. 11 Fig. 3.5.4. Creación de 6 Bandas entre los puntos extremos. 12 Fig. 3.5.5. Puntos Alto y Bajo de cada una de las bandas que forman el

subconjunto R seleccionado por el ABD de la nube de puntos dato.

12 Fig. 3.5.6. División de Andrew en puntos Inferiores y Superiores. 13 Fig. 3.5.7. Ejemplo de giro a la izquierda en la aplicación del algoritmo de

Graham (I).

13 Fig. 3.5.8. Ejemplo de giro a la izquierda en la aplicación del algoritmo de

Graham (II). Punto morado descartado del cierre.

14 Fig. 3.5.9. Resultado obtenido al aplicar Graham a una de las partes de la

división hecha por Andrew.



15 Fig. 3.5.11. Cierre Convexo Aproximado que resulta de la concatenación

del Superior e Inferior.

15 Fig. 3.5.12. Cierre Aproximado obtenido con el algoritmo de Bandas por

Defecto con 6 Bandas.

16 Fig. 3.5.13. Secuencia de pasos para intuir el error en ABD. 16 Fig. 3.6.1. Diferencia Cierre convexo y aproximado (ABE). 18 Fig. 3.6.2. Nube de puntos dato con distribución normal en un rectángulo. 20 Fig. 3.6.3. Puntos Extremos; Izquierdo y Derecho. 20 Fig. 3.6.4. Creación de 6 Bandas entre los puntos extremos. 21 Fig. 3.6.5. Puntos seleccionados por el ABE de la nube de puntos dato. 21 Fig. 3.6.6. División de Andrew en puntos Inferiores y Superiores. 22 Fig. 3.6.7. Ejemplo de giro a la izquierda en la aplicación del algoritmo de

Graham (I).

22 Fig. 3.6.8. Ejemplo de giro a la izquierda en la aplicación del algoritmo de

Graham (II). Punto descartado del Cierre.

23


- 91 -

Número. Descripción de la misma. (continuación ...) Pagina.Fig. 3.6.9. Resultado obtenido al aplicar Graham a una de las partes de la

división hecha por Andrew. (1 de 2) 23Fig. 3.6.10. Resultado obtenido al aplicar Graham a una de las partes de la

división hecha por Andrew. (2 de 2) 24Fig. 3.6.11. Cierre Convexo Aproximado que resulta de la concatenación

del Superior e Inferior. 24Fig. 3.6.12. Cierre Aproximado obtenido con el algoritmo de Bandas por

Exceso con 6 Bandas. 25Fig. 3.6.13. Secuencia de pasos para intuir el error en ABE. 25Fig. 3.7.1. Nube de puntos dato con distribución normal en un rectángulo. 29Fig. 3.7.2. Puntos Extremos: Derecho, Izquierdo, Superior e Inferior. 29Fig. 3.7.3. División en una cuadrícula de 6x6 entre los puntos extremos. 30Fig. 3.7.4. Puntos seleccionados por el ACD de la nube de puntos dato. 30Fig. 3.7.5. División de Andrew en puntos Inferiores y Superiores. 31Fig. 3.7.6. Ejemplo de giro a la izquierda en la aplicación del algoritmo de

Graham (I). 31Fig. 3.7.7. Ejemplo de giro a la izquierda en la aplicación del algoritmo de

Graham (II). 32Fig. 3.7.8. Resultado obtenido al aplicar Graham a una de las partes de la

división hecha por Andrew. 32Fig. 3.7.9. Resultado obtenido al aplicar Graham a una de las partes de la

división hecha por Andrew. 33Fig. 3.7.10. Cierre Convexo Aproximado que resulta de la concatenación

del Superior e Inferior. 33Fig. 3.7.11. Cierre Aproximado obtenido con el algoritmo de Cuadrículas

por Defecto con 6x6. 34Fig. 3.7.12. Secuencia de pasos para intuir el error en ACD. 34Fig. 3.8.1. Nube de puntos dato con distribución normal en un rectángulo. 38Fig. 3.8.2. Puntos Extremos: Derecho, Izquierdo, Superior e Inferior. 38Fig. 3.8.3. División en una cuadrícula de 6x6 entre los puntos extremos. 39Fig. 3.8.4. Puntos seleccionados por el ACE de la nube de puntos dato. 39Fig. 3.8.5. División de Andrew en puntos Inferiores y Superiores. 40Fig. 3.8.6. Ejemplo de giro a la izquierda en la aplicación del algoritmo de

Graham (I). 40Fig. 3.8.7. Ejemplo de giro a la izquierda en la aplicación del algoritmo de

Graham (II). 41Fig. 3.8.8. Resultado obtenido al aplicar Graham a una de las partes de la

división hecha por Andrew. 41Fig. 3.8.9. Resultado obtenido al aplicar Graham a una de las partes de la

división hecha por Andrew. 42Fig. 3.8.10. Cierre Convexo Aproximado que resulta de la concatenación

del Superior e Inferior. 42Fig. 3.8.11. Cierre Aproximado obtenido con el algoritmo de Cuadrículas

por Exceso con 6x6. 43


- 92 -

Número. Descripción de la misma. (Continuación ...) Pagina. Fig. 3.8.12. Secuencias de pasos para intuir el error en ACE. 43 Fig. 3.9.1. Nube de puntos dato con distribución normal en un rectángulo. 46 Fig. 3.9.2. Puntos Extremos: Derecho, Izquierdo, Superior e Inferior. 47 Fig. 3.9.3. Calculo del Foco del que partirán los rayos de proyección en el

punto medio de los extremos.

47 Fig. 3.9.4. Hallado punto más alejado de la nube en dirección del rayo de

proyección.

48 Fig. 3.9.5. Puntos seleccionados por el ARD de la nube de puntos dato. 48 Fig. 3.9.6. División de Andrew en puntos Inferiores y Superiores. 49 Fig. 3.9.7. Resultado obtenido al aplicar Graham a una de las partes de la






50 Fig. 3.9.10. Cierre Aproximado obtenido con el algoritmo de Rayos por

Defecto con 9 rayos.

51 Fig. 3.9.11. Secuencia de pasos para intuir el error en ARD. 51 Fig. 3.10.1. Nube de puntos dato con distribución normal en un rectángulo. 55 Fig. 3.10.2. Puntos Extremos: Derecho, Izquierdo, Superior e Inferior. 56 Fig. 3.10.3. Cálculo del Foco del que partirán los rayos de proyección en el

punto medio de los extremos.

56 Fig. 3.10.4. Línea Perpendicular al primer Rayo que paso por el punto más

alejado en esa dirección.

57 Fig. 3.10.5. Punto intersección de las líneas perpendiculares a los rayos 1º y

2º.

57 Fig. 3.10.6. Puntos seleccionados por el ARE con 9 rayos. 58 Fig. 3.10.7. División de Andrew en puntos Inferiores y Superiores. 58 Fig. 3.10.8. Resultado obtenido al aplicar Graham a una de las partes de la






60 Fig. 3.10.11. Cierre Aproximado obtenido con el algoritmo de Rayos por

Exceso con 9 rayos.

60 Fig. 3.10.12. Secuencia de pasos para intuir el error en ARE. 61 Fig. 4.2.1. Diagrama de clases para homogeneizar el acceso a la

aplicación.

65 Fig. 4.2.2. Diagrama de clases de la relación de generalización de los

algoritmos.

66 Fig. 4.2.3. Diagrama de clases para permitir volver a estados anteriores. 67 Fig. 4.2.4. Diagrama de clases de las reglas gráficas. 67 Fig. 4.2.5. Especialización de Puntos por herencia. 68


- 93 -

Número. Descripción de la misma. (Continuación ...) Pagina.Fig. 4.3.1. Diagrama de clases del patrón Factory Method. 70Fig. 4.3.2. Diagrama de clases del patrón State. 71Fig. 4.3.3. Diagrama de clases del patrón Composite. 72Fig. 4.3.4. Diagrama de clases del patrón Observer. 73Fig. 4.3.5. Diagrama de clases del patrón Builder. 75Fig. 4.3.6. Diagrama de clases del patrón Command. 76Fig. 5.1.1. Captura de la página de entrada de la web. 77Fig. 5.1.2. Esquema de las dos formas de ejecución de la aplicación. 78Fig. 5.1.3. Captura de la interface gráfica de la aplicación. 79Fig. 5.2.1. Captura marco de interface Abrir-Archivo. 80Fig. 5.2.2. Imagen de la inserción de un punto con ratón. 81Fig. 5.2.3. Imagen de la inserción de un punto por sus coordenadas. 81Fig. 5.2.4. Imagen de inserción de puntos aleatorios. 82Fig. 5.2.5. Ejemplo de una nube de puntos generada de forma aleatoria por

el programa. 82Fig. 5.3.1. Botones de control de ejecución de los algoritmos geométricos. 83Fig. 5.3.2. Tres pasos de la ejecución del ABD. 84Fig. 5.4.1. Gráfica de tiempos para una ejecución real de los 6 algoritmos. 86


- 94 -

9. BIBLIOGRAFÍA Y ENLACES.

Bruce Eckel, Thinking in Patterns. Sitio web: http://www.mindview.net/Books/TIPatterns/

CGAL (Computational Geometry Algomithms Library) Sitio web: http://www.cgal.org/

Christopher Alexander, Sara Ishikawa, Murray Silverstein, Max Jacobson, Ingrid Fiksdahl-King y Shlomo Angel, 1977. A Pattern Language: Towns/ Building /Construction, Oxford University Press.

Cohen Isaac, 1996. CGI/Perl et Javascript, Editions Eyrolles.

Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, 1995 Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley.

G. Brassard, P. Bratley, 1998. Fundamentos de algoritmia, Prentice Hall.

García Marco Javier, Tramullas saz Jesús, 1996. World Wide Web: Fundamentos, navegación y lenguajes de la red mundial de información. Ra-Ma.

J. O´Rourke, 1998. Computational geometry in C. Cambridge University Press.

James W. Cooper, 1998. The Design Patterns Java Companion. IBM Thomas J. Watson Research Center. Sitio web: http://www.patterndepot.com/put/8/JavaPatterns.htm

Java Sun, The Java Tutorial: A practical guide for programmers, Sitio web: http://java.sun.com/reference/docs/index.html

Mark Allen Weiss, 1995. Estructuras de datos y Algoritmos, Addison-Wesley.

http://www.cgal.org/

http://java.sun.com/reference/docs/index.html


- 95 -

Mark de Berg et Al. Otfrded. 1997. Computational geometry: Algorithms and applications (Second edition). Book Data Limited, UK

Mark Grand, 1998. Patterns in Java (volume 1), John Wiley & Sons.

Mark Grand, 1999. Patterns in Java (volume 2), John Wiley & Sons.

NCSA. Beginner's Guide to HTML. Sitio web: http://www.ncsa.uiuc.edu/General/Internet/WWW/HTMLPrimer.html

Naughton Patrick, 1997. The Java Handbook, McGRAW-HILL.

Rumbaugh, James, Blaha, Michael, Premerlani, William, Eddy, Friederick y Lorensen William, 1991. Modelado y Diseño Orientado a Objetos. Prentice Hall.

Stephen Stelting y Olav Maassen. 2003. Patrones de diseño aplicados a Java. Pearson Educacion, S.A., Traducido de: Applied Java Patterns. 2002. Sun Microsystems, Inc.

UML (Unified Modeling Language) o Lenguaje Unificado de Modelado. Popkin Software and Systems. Sitio web: http://es.tldp.org/Tutoriales/doc-modelado-sistemas-UML/multiple-html/index.html

Vico open modeling, s.l. Catalogo de Patrones en Java y C++ Sitio web: http://vico.org/pages/PatronsDisseny.html

Wolfgang Pree, 1994. Design Patterns for Object Oriented Software Development, Addison-Wesley.

W3C. HyperText Markup Languaje (HTML). Sitio web: http://www.w3.org/MarkUp

http://www.ncsa.uiuc.edu/General/Internet/WWW/HTMLPrimer.html

http://es.tldp.org/Tutoriales/doc-modelado-sistemas-UML/multiple-html/index.html

http://es.tldp.org/Tutoriales/doc-modelado-sistemas-UML/multiple-html/index.html

http://vico.org/pages/PatronsDisseny.html

http://www.w3.org/MarkUp/

Documents

CIERRES CONVEXOS APROXIMADOS - dma.fi.upm.es · (también conocido como Envolvente Convexa o Convex Hull) al menor conjunto convexo del plano que contiene a S. De forma intuitiva