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_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_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_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_addRandomVertex2D(self):
T = Triangulation()
self.assertEqual(T.getVerts(), [])
T.addRandomVertex2D(15, 5)
self.assertEqual(len(T.getVerts()), 15)
for vert in T.getVerts():
self.assertLessEqual(vert.getX(), 15)
self.assertLessEqual(vert.getY(), 15)
return
# Author: Sergio Alvarez Medina # Creation Date: 30/03/2019 # E-mail: [email protected] # 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...")
# E-mail: [email protected] # Mejora triangulo insertando punto en el centroide. # se compara mismo procedimiento con Visualtest10.py. 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 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)
# Author: Sergio Alvarez Medina # Creation Date: 18/03/2019 # 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
# Creation Date: 30/03/2019 # E-mail: [email protected] # pruebas de inseercion delaunay con los puntos en los ejes. # Se agregan puntos aparte luego de eso. 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()
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_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
# Creation Date: 10/05/2019 # E-mail: [email protected] # 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)
# Mejora triangulo insertando puntos en centroide hasta que todos los triangulos
# tengan un angulo mayor al especificado.
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
Nvertices = 30
anguloMinimo = 30
T2 = Triangulation()
verts = []
# Añadimos puntos al azar
np.random.seed(12) # 12 45 29
for i in range(1, Nvertices):
verts.append(
Vertex(Point(np.random.random() * 1000,
np.random.random() * 1000)))
# iniciamos triangulacion
T2.makeDelaunay(verts)
# dibujamos triangulacion
T2.draw2D(lineWidth=0.5, save=True, name="Inicial", show=False, close=True)
