def test_getBoundingTriangle2D(self):
T = Triangulation()
for i in range(15):
v1 = Vertex(
Point(np.random.random() * 54,
np.random.random() * 100))
v2 = Vertex(
Point(np.random.random() * 54,
np.random.random() * 100))
v3 = Vertex(
Point(np.random.random() * 54,
np.random.random() * 100))
T.addVertex(v1)
T.addVertex(v2)
T.addVertex(v3)
triangle = T.getBoundingTriangle2D()
for vert in T.getVerts():
self.assertEqual(
Triangulation.Orient2D(vert, triangle.getVert1(),
triangle.getVert2()), True)
self.assertEqual(
Triangulation.Orient2D(vert, triangle.getVert2(),
triangle.getVert3()), True)
self.assertEqual(
Triangulation.Orient2D(vert, triangle.getVert3(),
triangle.getVert1()), True)
return
def test_getTriangleOppositeTo(self):
triangle1 = Triangle(Vertex(Point(1, 1)), Vertex(Point(1, 2)),
Vertex(Point(3, 4)))
triangle2 = Triangle(Vertex(Point(1, 5)), Vertex(Point(1, 6)),
Vertex(Point(2, 5)))
mainTriang = Triangle(Vertex(Point(1, 2)), Vertex(Point(1, 3)),
Vertex(Point(4, 1)), triangle1, triangle2)
self.assertEqual(
mainTriang.getTriangleOppositeTo(
mainTriang.getVert1()) == triangle1, True, "Opposite to vert1")
self.assertEqual(
mainTriang.getTriangleOppositeTo(
mainTriang.getVert2()) == triangle2, True, "Oposite to vert2")
self.assertEqual(
mainTriang.getTriangleOppositeTo(mainTriang.getVert3()) == None,
True, "Non existen opposite triangle")
self.assertEqual(
mainTriang.getTriangleOppositeTo(Vertex(Point(1, 2))) == triangle1,
True, "Opposite to a new vertex with same coordinates")
return
def test_getNextVert(self):
triangle1 = Triangle(Vertex(Point(1, 1)), Vertex(Point(3, 3)),
Vertex(Point(2, 2)))
# Comprobamos que sea circular
self.assertEqual(
triangle1.getNextVertex(triangle1.getVert1()).equal(
triangle1.getVert2()), True, "Caso normal 1")
self.assertEqual(
triangle1.getNextVertex(triangle1.getVert2()).equal(
triangle1.getVert3()), True, "Caso normal 2")
self.assertEqual(
triangle1.getNextVertex(triangle1.getVert3()).equal(
triangle1.getVert1()), True, "Caso normal 3")
# comprobamos vertices externos
self.assertEqual(
triangle1.getNextVertex(Vertex(Point(1, 1))).equal(
triangle1.getVert2()), True,
"No comprueba vertices creados externos al triangulo.")
self.assertEqual(
triangle1.getNextVertex(
triangle1.getNextVertex(Vertex(Point(1, 1)))).equal(
triangle1.getVert3()), True,
"No es circular con vertices externos.")
def test_Orient2D(self):
# comprueba que funciona para el caso normal
v1 = Vertex(Point(-1, 0))
v2 = Vertex(Point(1, 0))
v3 = Vertex(Point(0.5, 0.5))
self.assertEqual(Triangulation.Orient2D(v1, v2, v3), True)
self.assertEqual(Triangulation.Orient2D(v3, v2, v1), False)
# comprueba que funciona para distancias muy pequeñas
v4 = Vertex(Point(0.5, 0.5))
v5 = Vertex(Point(0.5, 0.56))
v6 = Vertex(Point(0.49, 0.5))
self.assertEqual(Triangulation.Orient2D(v4, v5, v6), True)
self.assertEqual(Triangulation.Orient2D(v6, v5, v4), False)
self.assertRaises(AssertionError,
lambda: Triangulation.Orient2D(v6, v5, v6))
self.assertRaises(AssertionError,
lambda: Triangulation.Orient2D(v1, v1, v6))
# comprueba que metodo resulta cuando se tratan de puntos colineales
v7 = Vertex(Point(-1, 0))
v8 = Vertex(Point(0, 0))
v9 = Vertex(Point(1, 0))
self.assertEqual(Triangulation.Orient2D(v7, v8, v9), True)
self.assertEqual(Triangulation.Orient2D(v9, v8, v7), True)
return
def test_popTriangle(self):
triangle1 = Triangle(Vertex(Point(-1, 0)), Vertex(Point(1, 0)),
Vertex(Point(0, 1)))
triangle2 = Triangle(Vertex(Point(-1, 0)), Vertex(Point(1, 0)),
Vertex(Point(0, -1)))
Tr = Triangulation()
Tr.addTriangle(triangle1)
Tr.addTriangle(triangle2)
# quitar triangulo con la misma direccion
self.assertEqual(len(Tr.getTriangles()) == 2, True)
self.assertEqual(Tr.popTriangle(triangle2), True)
self.assertEqual(Tr.popTriangle(triangle2), False)
self.assertEqual(len(Tr.getTriangles()) == 1, True)
# quitar triangulo con distinta direccion pero mismos vertices
self.assertEqual(
Tr.popTriangle(
Triangle(Vertex(Point(-1, 0)), Vertex(Point(1, 0)),
Vertex(Point(0, 1)))), True)
self.assertEqual(len(Tr.getTriangles()) == 0, True)
return
def test_distance(self):
v1 = Vertex(Point(0, 0))
v2 = Vertex(Point(2, 0))
v3 = Vertex(Point(-3, -4))
v4 = Vertex(Point(3, 4))
self.assertEqual(v1.distance(v2), 2,
"No calcula distancia normalmente")
self.assertEqual(v3.distance(v4), 10,
"No calcula distancia en diagonal o negativos")
return
def __init__(self, point=Point()):
"""
Constructor de la clase vertice
:param punto: Point
"""
assert type(point) == Point
self.__point = point
def test_getVertexNotShared(self):
triangle1 = Triangle(Vertex(Point(1, 1)), Vertex(Point(1, 2)),
Vertex(Point(2, 1)))
triangle2 = Triangle(Vertex(Point(1, 1)), Vertex(Point(1, 2)),
Vertex(Point(3, 1)))
self.assertEqual(
Triangulation.getVertexsNotShared(triangle1, triangle2)[0].equal(
Vertex(Point(2, 1))), True)
self.assertEqual(
Triangulation.getVertexsNotShared(triangle1, triangle2)[1].equal(
Vertex(Point(3, 1))), True)
return
def test_deleteTriangleThatContains(self):
v1 = Vertex(Point(1, 2))
v2 = Vertex(Point(2, 2))
v3 = Vertex(Point(3, 1))
v4 = Vertex(Point(5, 5))
t1 = Triangle(v1, v2, v3)
t2 = Triangle(v2, v3, v4)
T = Triangulation()
T.addTriangle(t1)
T.addTriangle(t2)
self.assertEqual(
T.getTriangles() == [t1, t2] or T.getTriangles() == [t2, t1], True,
"No entrega los triangulos que se le agregaron.")
T.deleteTrianglesThatContain(v4)
self.assertEqual(T.getTriangles() == [t1], True,
"No elimina triangulo que contiene el vertice v4.")
T.deleteTrianglesThatContain(v4)
self.assertEqual(
T.getTriangles() == [t1], True,
"Elimina triangulos aun cuando ningun triangulo contiene el vertice."
)
T.deleteTrianglesThatContain(v2)
self.assertEqual(T.getTriangles() == [], True,
"No esta eliminando los triangulos.")
return
def test_getTriangleThatContain(self):
T = Triangulation()
v1 = Vertex(Point(-1, 0))
v2 = Vertex(Point(1, 0))
v3 = Vertex(Point(0, 1))
v4 = Vertex(Point(0, 0.5))
v5 = Vertex(Point(2, 2))
v6 = Vertex(Point(-1, 0))
v7 = Vertex(Point(1, 0))
v8 = Vertex(Point(0, -1))
v9 = Vertex(Point(0, 0))
triangle = Triangle(v1, v2, v3)
triangle2 = Triangle(v6, v8, v7)
triangle.setTriangle3(triangle2)
triangle2.setTriangle2(triangle)
T.addTriangle(triangle)
T.addTriangle(triangle2)
self.assertEqual(T.getTriangleThatContain(v4)[0], triangle)
self.assertEqual(T.getTriangleThatContain(v5), [])
self.assertEqual(
T.getTriangleThatContain(v9)[0] == triangle
or T.getTriangleThatContain(v9)[1] == triangle, True)
self.assertEqual(
T.getTriangleThatContain(v9)[0] == triangle2
or T.getTriangleThatContain(v9)[1] == triangle2, True)
return
def test_InCircle(self):
# comprueba que funciona en el caso normal
v1 = Vertex(Point(-1, 0))
v2 = Vertex(Point(1, 0))
v3 = Vertex(Point(0, 0.5))
self.assertEqual(
Triangulation.InCircle(v1, v2, v3, Vertex(Point(0, 0.25))), True)
self.assertEqual(
Triangulation.InCircle(v1, v2, v3, Vertex(Point(15, 15))), False)
self.assertEqual(
Triangulation.InCircle(v1, v2, v3, Vertex(Point(0, -0.1))), True)
self.assertEqual(
Triangulation.InCircle(v1, v2, v3, Vertex(Point(0.9, 0))), True)
return
def test_setTriangleOppositeTo(self):
triangle1 = Triangle()
triangle2 = Triangle(Vertex(Point(1, 2)), Vertex(Point(2, 2)),
Vertex(Point(1, 3)))
self.assertEqual(
triangle2.setTriangleOppositeTo(Vertex(Point(1, 2)), triangle1),
True)
self.assertEqual(triangle1 == triangle2.getTriangle1(), True)
triangle3 = Triangle()
self.assertEqual(
triangle2.setTriangleOppositeTo(Vertex(Point(1, 5)), triangle1),
False)
self.assertEqual(
triangle2.setTriangleOppositeTo(Vertex(Point(1, 3)), triangle3),
True)
self.assertEqual(triangle3 == triangle2.getTriangle3(), True)
return
from Logic.Point import Point
from Logic.Triangulation import Triangulation
from Logic.Vertex import Vertex
from Logic.Triangle import Triangle
Nvertices = 50
T2 = Triangulation()
verts = []
# Añadimos puntos al azar
np.random.seed(12)
for i in range(1, Nvertices):
verts.append(
Vertex(Point(np.random.random() * 1000,
np.random.random() * 1000)))
# iniciamos triangulacion
T2.makeDelaunay(verts)
# dibujamos el camino completo
for triangle in T2.Lepp(T2.getTriangles()[-1])[0]:
triangle.draw2D(show=False, width=2)
# dibujamos primer triangulo para saber donde comenzamos
T2.Lepp(T2.getTriangles()[-1])[0][0].draw2D(show=False, width=4)
# dibujamos triangulacion
T2.draw2D(lineWidth=0.5)
T2.improveTriangle(T2.getTriangles()[-1])
# E-mail: [email protected] # Archivo que contiene un test visual sobre el proceso de delaunay. import numpy as np from Logic.Point import Point from Logic.Triangulation import Triangulation from Logic.Vertex import Vertex from Logic.Triangle import Triangle T = Triangulation() # annadimos un punto a la triangulacion P = [ Vertex(Point(6, 87)), Vertex(Point(35, 88)), Vertex(Point(34, 16)), Vertex(Point(87, 75)), Vertex(Point(50, 60)) ] #P = [Vertex(Point(6,87)),Vertex(Point(35,88))] T.makeDelaunay(P) T.printTriangles2D() T.draw2D() ##################################################################### Npuntos = 40 T2 = Triangulation()
from Logic.Point import Point
from Logic.Triangulation import Triangulation
from Logic.Vertex import Vertex
from Logic.Triangle import Triangle
Nvertices = 50
T2 = Triangulation()
verts = []
# Añadimos puntos al azar
for i in range(1, Nvertices):
# Puntos que se añaden son muy lejanos unos de otros, el error cobra importancia en estos casos.
verts.append(Vertex(Point(-500, 0)))
verts.append(Vertex(Point(500, 0)))
verts.append(Vertex(Point(0, 1)))
# iniciamos triangulacion
T2.makeDelaunay(verts)
# dibujamos el camino completo
for triangle in T2.Lepp(T2.getTriangles()[-1]):
triangle.draw2D(show=False, width=2)
# dibujamos primer triangulo para saber donde comenzamos
T2.Lepp(T2.getTriangles()[-1])[0].draw2D(show=False, width=4)
# dibujamos triangulacion
T2.draw2D(lineWidth=0.5)
T2.improveTriangle(T2.getTriangles()[-1])
# Author: Sergio Alvarez Medina # Creation Date: 30/03/2019 # E-mail: [email protected] # Insercion delaunay solo con puntos en los ejes import numpy as np from Logic.Point import Point from Logic.Triangulation import Triangulation from Logic.Vertex import Vertex from Logic.Triangle import Triangle Nvertices = 10 T2 = Triangulation() verts = [] # Añadimos puntos al azar for i in range(1, Nvertices): verts.append(Vertex(Point(-100 * i, 0))) verts.append(Vertex(Point(100 * i, 0))) verts.append(Vertex(Point(0, 100 * i))) verts.append(Vertex(Point(0, -100 * i))) T2.makeDelaunay(verts) T2.draw2D(lineWidth=0.5)
import numpy as np
from Logic.Point import Point
from Logic.Triangulation import Triangulation
from Logic.Vertex import Vertex
from Logic.Triangle import Triangle
Nvertices = 10
T2 = Triangulation()
verts = []
# Añadimos puntos al azar
for i in range(1, Nvertices):
verts.append(Vertex(Point(-1000 * i, 0)))
verts.append(Vertex(Point(1000 * i, 0)))
verts.append(Vertex(Point(0, 1000 * i)))
verts.append(Vertex(Point(0, -1000 * i)))
T2.makeDelaunay(verts)
T2.draw2D(lineWidth=0.5)
T2.addVertexToDelaunay(Vertex(Point(1000, 1000)))
T2.draw2D()
T2.addVertexToDelaunay(Vertex(Point(-1000, 1000)))
T2.draw2D()
T2.addVertexToDelaunay(Vertex(Point(-10000, 7000)))
T2.draw2D()
from Logic.Point import Point
from Logic.Triangulation import Triangulation
from Logic.Vertex import Vertex
from Logic.Triangle import Triangle
Nvertices = 50
T2 = Triangulation()
verts = []
# Añadimos puntos al azar
np.random.seed(12)
for i in range(1, Nvertices):
verts.append(Vertex(Point(np.random.random() * 1000, np.random.random() * 1000)))
# iniciamos triangulacion
T2.makeDelaunay(verts)
# dibujamos el camino completo
for triangle in T2.Lepp(T2.getTriangles()[-25])[0]:
triangle.draw2D(show=False, width=2)
# dibujamos primer triangulo para saber donde comenzamos
T2.Lepp(T2.getTriangles()[-25])[0][0].draw2D(show=False, width=4)
# dibujamos triangulacion
T2.draw2D(lineWidth=0.5)
T2.improveTriangleCentroid(T2.getTriangles()[-25])
T2.draw2D()
# Insercion delaunay con grilla extremadamente grande.
import numpy as np
from Logic.Point import Point
from Logic.Triangulation import Triangulation
from Logic.Vertex import Vertex
from Logic.Triangle import Triangle
Npuntos = 20
T2 = Triangulation()
verts = []
print("Annadiendo puntos")
# Añadimos puntos al azar
for i in range(Npuntos):
for j in range(Npuntos):
verts.append(Vertex(Point(i * 10, j * 10)))
for i in range(Npuntos):
for j in range(Npuntos):
verts.append(Vertex(Point(i * 10 + 5, j * 10 + 5)))
print("Ejecutando Delaunay...")
T2.makeDelaunay(verts)
print("Dibujando...")
T2.draw2D(lineWidth=0.5)
# Comprueba triangulacion en un rectangulo para comprobar el insertar un punto en la segunda arista mas larga.
import numpy as np
import matplotlib as plt
from Logic.Point import Point
from Logic.Triangulation import Triangulation
from Logic.Vertex import Vertex
from Logic.Triangle import Triangle
anguloMinimo = 30
T2 = Triangulation()
# Añadimos puntos al azar
t1 = Triangle(Vertex(Point(0, 0)), Vertex(Point(1000, 0)),
Vertex(Point(1000, 100)), None, None, None)
t2 = Triangle(Vertex(Point(0, 0)), Vertex(Point(1000, 100)),
Vertex(Point(0, 100)), None, None, None)
t1.setTriangle2(t2)
t2.setTriangle3(t1)
T2.addTriangle(t1)
T2.addTriangle(t2)
# mostramos la configuracion inicial
T2.draw2D(lineWidth=0.5)
# Mejoramos triangulacion mientras existan trianglos malos
T2.mejorarTriangulos(angle=anguloMinimo,