ALGORITMO VORAZ

Victor Rojas,Kevin Ortega

[Direccin de correo electrnico]

Anlisis de Algoritmo - Triangulacin

Contenido
Introduccin........................................................................................................ 2
Como lo abordamos............................................................................................ 2
Parte lgica...................................................................................................... 5
Parte Grfica.................................................................................................... 5
Salida de la aplicacin........................................................................................ 6

Introduccin
ste informa trata sobre la triangulacin de una nube de puntos, es decir, que
a partir de una cantidad de puntos finitos entregados por el usuario se
pretende realizar la unin de cada uno de los puntos, con el fin de poder
convertir dicha nube de puntos en un rea compuesta por una cantidad
determinada de tringulos que se forman a partir de la unin de dichos puntos.
A partir de este principio se pretende que cada uno de los puntos pase a ser un
vrtice de un tringulo. La caracterstica principal de la problemtica planteada
consiste en realizar la triangulacin del rea, sin embargo, se plantea una
restriccin a la problemtica, que consiste en que las lneas que unen los
puntos dados no se deben sobreponer a otras, entonces, se deben comprobar
las uniones previamente antes de realizar la unin de los puntos.
El problema se resuelve en lenguaje Python con la estrategia de un algoritmo
voraz, quien es aplicado a problemas de optimizacin con la idea de buscar
una buena solucin

Como lo abordamos
La metodologa de trabajo que se utiliz para la solucin del problema consiste
en la implementacin de un algoritmo voraz, ste mtodo trata de dar un
resultado a partir de un conjunto de soluciones candidatas, las cuales no
siempre son la mejor. Para llegar a la solucin, se procede paso a paso
realizando la mejor eleccin entre las posibles (usando una funcin objetivo
que respeta un conjunto de restricciones). En estos algoritmos las soluciones se
pueden representar como una secuencia de decisiones, las cuales se realizarn
de forma irreversible. Con respecto al alcance de este tipo de algoritmos, una
aproximacin voraz consiste en que cada elemento a considerar se evala una
nica vez, siendo descartado o seleccionado.
En base a la solucin general del problema se realizar una traza global de
uniones que se crean entre los puntos entregados por el usuario, para tener
todas las posibles combinaciones de lneas o segmentos de recta que puedan
unir los puntos entregados. A partir de esto se genera una triangulacin
completa a partir de la nube de puntos entregados, sin embargo, aqu las
lneas an se intersectan.
Luego se construye una lista de soluciones a partir de comparaciones de los
segmentos formados entre los puntos, con todos y cada uno de los otros
segmentos que se encuentran en el listado de soluciones y si este no se
intersecta con ninguno pasa a formar parte de soluciones. El proceso se
muestra en la imagen 1

Imagen 1

Para solucionar el problema de las intersecciones ocupamos el algoritmo de

ORourke anunciado en su libro Computational Geometry in C. La principal
idea del algoritmo es verificar si los dos vrtices de un segmento se
encuentran en lados opuestos de la lnea formada por el otro segmento y
viceversa. Existen casos en los que un vrtice de un segmento pertenece al
otro segmento, por lo que este algoritmo no los tomar en cuenta como una
interseccin.
Los pasos son los siguientes:
Se crear una funcin que calcule el rea de un tringulo definido por tres
puntos en el plano:
def area_triang(a,b,c):
return (b[0]-a[0])*(c[1]-a[1])-(c[0]-a[0])*(b[1]-a[1])

La funcin area_triang nos regresa un rea positiva o negativa segn el orden

en que le demos los puntos pero siempre ser el mismo resultado sin tomar en
cuenta el signo.
Luego se construye una funcin (side_p_to_seg) con la cual podemos saber de
que lado se encuentra un punto p de una lnea formada por el
segmento (v1,v2)
def side_p_to_seg(v1,v2,p):
area = area_triang(v1,v2,p)
if area > 0 :
lado = "izq"
elif area < 0 :
lado = "der"
else:
lado = "col"
return lado

Y por ltimo, para verificar si dos segmentos se intersectan se construye la

funcin interseccin de segmentos.
def seg_intersection(u1,u2,v1,v2):
if (side_p_to_seg(u1,u2,v1) == "col" or
side_p_to_seg(u1,u2,v2) == "col" or
side_p_to_seg(v1,v2,u1) == "col" or
side_p_to_seg(v1,v2,u2) == "col"):
return False
elif (((side_p_to_seg(u1,u2,v1) == "izq" and

side_p_to_seg(u1,u2,v2)
(side_p_to_seg(u1,u2,v1)
side_p_to_seg(u1,u2,v2)
((side_p_to_seg(v1,v2,u1)
side_p_to_seg(v1,v2,u2)
(side_p_to_seg(v1,v2,u1)
side_p_to_seg(v1,v2,u2)
return True
else:
return False

==
==
==
==
==
==
==

"der") or
"der" and
"izq"))and
"der" and
"izq") or
"izq" and
"der"))):

Donde u1,u2,v1,v2 son puntos pertenecientes a las rectas U y V

respectivamente.
En el cdigo en Python (imagen 2) que se implement se puede ver con mas
claridad a que lneas perteneces los puntos de U y V

Imagen 2

Como ultima funcin utilizada para el desarrollo de la solucin tenemos el

algoritmo de ordenamiento Bubblesort, quien ordena el listado de soluciones a
partir de su longitud de menor mayor, con el fin de obtener una solucin ms
ordenada.

Parte lgica
El cdigo cuenta con 8 funciones, una clase lnea ms la funcin principal main.

Las lneas las creamos con una clase lnea (imagen 3)

Imagen 3

Mtodo bubbleSort
La interseccin que cuenta con 3 funciones descritas ateriormente:
o area_triang
o side_p_to_seg
o seg_intersection
Funcin para leer los puntos (lee_puntos)
Dibujar:
o Dibuja_nube_puntos
o Dibuja_lineas
Funciones para los botones del programa:
o Dibujar
o Empezar
Y la funcin principal Main

Parte Grfica
Para la grfica del cdigo se ocup la biblioteca de Python TKinter. Con la
cual se dibujaron los puntos y lneas que forman la nube.
Para dibujar lneas y puntos se ocupa la funcin canvas.
Para los puntos, el segmento de cdigo es:
canvas.create_oval(int(puntos[i][0])-2, int(puntos[i][1])-2,int(puntos[i][0])+2,
int(puntos[i][1])+2, width=1, fill='red')
Para las lineas, el segmento de cdigo es:
canvas.create_line(ArregloSolucion[tam_solucion].x0,
ArregloSolucion[tam_solucion].y0,ArregloSolucion[tam_solucion].x1,
ArregloSolucion[tam_solucion].y1, width=1, fill='blue')

Salida de la aplicacin
Con una cantidad de 100 puntos se obtiene la siguiente triangulacin.