def _retriangulate(self):
"""Triangulate the shape
"""
if len(self.vertices) < 2:
self._tri_edges = np.array([])
self._tri_faces = np.array([])
self._tri_vertices = self.vertices
return
if len(self.contour) > 1:
n, _ = self.contour.shape
contour_edges = np.vstack([np.arange(n), (np.arange(n) + 1) % n]).transpose()
triangulation_vertices = np.vstack([self.vertices, self.contour])
triangulation_segments = np.vstack([self.edges, contour_edges + len(self.edges)])
triangulate_parameters = dict(vertices=triangulation_vertices,
segments=triangulation_segments, holes=self.get_interior_point(self.contour))
self._tri = tr.triangulate(triangulate_parameters, "p")
else:
triangulate_parameters = dict(vertices=self.vertices, segments=self.edges)
self._tri = tr.triangulate(triangulate_parameters, "p")
if "segments" in self._tri.keys():
self._tri_edges = self._tri["segments"]
else:
self._tri_edges = self.edges
self._tri_faces = self._tri["triangles"]
self._tri_vertices = self._tri["vertices"]
def testSquare():
ptlist = {
"vertices": np.array(
((0.0, 0.0), (0.5, 0.0), (1.0, 0.0), (0.0, 0.5), (0.5, 0.5), (1.0, 0.5), (0.0, 1.0), (0.5, 1.0), (1.0, 1.0))
)
}
t = triangle.triangulate(ptlist)
t1 = triangle.triangulate(ptlist, "qa0.001")
triangle.plot.compare(plt, t, t1)
# plt.show()
L, M = FE.assembleMatrices(t)
# print L
# print '\n\n'
# print M
np.savetxt("textL", L)
np.savetxt("textM", M)
eig = FE.eigenvalues(L, M)
elist = eig[0]
efunc = eig[1]
print elist[0]
print elist[1]
print elist[2]
# vertices = np.asarray(t['vertices'])
# faces = np.asarray(t['triangles'])
# x = vertices[:,0]
# y = vertices[:,1]
# z = efunc[1]
# plt.figure()
# plt.tricontourf(x,y,faces,z,cmap='afmhot')
# plt.show()
print "****************************"
L, M = FE.assembleMatrices(t1)
eig = FE.eigenvalues(L, M)
elist = eig[0]
efunc = eig[1]
for j in range(10):
print elist[j]
vertices = np.asarray(t1["vertices"])
faces = np.asarray(t1["triangles"])
x = vertices[:, 0]
y = vertices[:, 1]
z = efunc[:, 5]
plt.figure()
plt.tricontourf(x, y, z, 100, cmap="afmhot")
plt.show()
print "***************************\n\n\n\n\n"
def obtainFullTria(x, y):
try:
y_temp, x_temp = np.meshgrid(y, x)
grid4 = np.array(zip(x_temp.ravel(), y_temp.ravel()))
# grid4 = np.array([(xx,yy) for xx in x for yy in y])
myPloy_with_grid = dict({'vertices': grid4})
# raise
# 画出PLSG
plt.figure()
ax1 = plt.subplot(221, aspect='equal')
triplt.plot(ax1, **myPloy_with_grid)
# plt.show()
# 进行网格剖分
myMesh_tria = triangle.triangulate(myPloy_with_grid)
ax2 = plt.subplot(222, aspect='equal')
triplt.plot(ax2, **myMesh_tria)
# plt.show()
d = list(itertools.permutations([0, 1, 2], r=2))
e = [myMesh_tria['triangles'][:, d[ii]] for ii in xrange(len(d))]
edges = np.vstack(e)
diff = edges[:, 0] - edges[:, 1]
edges_2 = edges[diff > 0, :]
frame = pd.DataFrame(edges_2)
# print frame
# print frame[frame.duplicated()]
dup = list(frame.duplicated() == False)
dup = [ii for ii, _ in enumerate(dup)]
edges_3 = edges_2[dup, :]
# print edges_3
# print dup
myPloy_with_seg = myPloy_with_grid
myPloy_with_seg['segments'] = edges_3
ax3 = plt.subplot(223, aspect='equal')
triplt.plot(ax3, **myPloy_with_seg)
for ii in xrange(myPloy_with_seg['vertices'].shape[0]):
ax1.text(myPloy_with_seg['vertices'][ii, 0],
myPloy_with_seg['vertices'][ii, 1], ii)
# plt.show()
#
# 形成最终完整的mesh进行保存
myMesh_tria_2 = triangle.triangulate(myPloy_with_seg, 'p')
ax4 = plt.subplot(224, aspect='equal')
triplt.plot(ax4, **myMesh_tria_2)
plt.show()
return myMesh_tria_2
except Exception as e:
print e
print grid4.shape
raise
def testFE():
ptlist = {"vertices": np.array(((0, 0), (1, 0), (1, 1), (0, 1)))}
triang = triangle.triangulate(ptlist)
print triang
print "\n\n"
print triang["vertices"]
print triang["triangles"]
triangle.plot.compare(plt, ptlist, triang)
plt.show()
print "\n\nNow testing the FE assembly ..."
L, M = FE.assembleMatrices(triang)
elist = FE.eigenvalues(L, M)[0]
elist.sort()
print "eigenvalues:"
for j in elist:
print j
triangle.plot.compare(plt, ptlist, triang)
plt.show()
triang = triangle.triangulate(triang, "rqa0.1")
L, M = FE.assembleMatrices(triang)
elist = FE.eigenvalues(L, M)[0]
elist.sort()
print "\n\neigenvalues:"
for j in elist:
print j
triangle.plot.compare(plt, ptlist, triang)
plt.show()
triang = triangle.triangulate(triang, "rqa0.01")
L, M = FE.assembleMatrices(triang)
elist = FE.eigenvalues(L, M)[0]
elist.sort()
print "\n\neigenvalues:"
for j in elist:
print j
triangle.plot.compare(plt, ptlist, triang)
plt.show()
def create_mesh(
points: List[List[float]],
facets: List[List[float]],
holes: List[List[float]],
control_points: List[List[float]],
mesh_sizes: Union[List[float], float],
coarse: bool,
):
"""Creates a quadratic triangular mesh using the triangle module, which utilises the code
'Triangle', by Jonathan Shewchuk.
:param points: List of points *(x, y)* defining the vertices of the cross-section
:type points: list[list[float, float]]
:param facets: List of point index pairs *(p1, p2)* defining the edges of the cross-section
:type points: list[list[int, int]]
:param holes: List of points *(x, y)* defining the locations of holes within the cross-section.
If there are no holes, provide an empty list [].
:type holes: list[list[float, float]]
:param control_points: A list of points *(x, y)* that define different regions of the
cross-section. A control point is an arbitrary point within a region enclosed by facets.
:type control_points: list[list[float, float]]
:param mesh_sizes: List of maximum element areas for each region defined by a control point
:type mesh_sizes: list[float]
:param bool coarse: If set to True, will create a coarse mesh (no area or quality
constraints)
:return: Dictionary containing mesh data
:rtype: dict()
"""
if not isinstance(mesh_sizes, list):
mesh_sizes = [mesh_sizes]
tri = {} # create tri dictionary
tri["vertices"] = points # set point
tri["segments"] = facets # set facets
if holes:
tri["holes"] = holes # set holes
# prepare regions
regions = []
for (i, cp) in enumerate(control_points):
regions.append([cp[0], cp[1], i, mesh_sizes[i]])
tri["regions"] = regions # set regions
# generate mesh
if coarse:
mesh = triangle.triangulate(tri, "pAo2")
else:
mesh = triangle.triangulate(tri, "pq30Aao2")
return mesh
def init(points, params=None):
if params:
triangulation = tr.triangulate(dict(vertices=np.array(points)), params)
else:
triangulation = tr.triangulate(dict(vertices=np.array(points)))
triangulation[SRC_POINT_MARKERS] = [
i < len(points) for i in range(len(triangulation[VERTICES]))
]
triangulation[VERTICES] = [*triangulation[VERTICES]]
triangulation[VERTEX_MARKERS] = [*triangulation[VERTEX_MARKERS]]
return triangulation
def main():
mopen = Dynearthsol(modelname)
rho = mopen.read_field(nframe, 'density')
conn = mopen.read_field(nframe, 'connectivity')
coord = mopen.read_field(nframe, 'coordinate')
bcflag = mopen.read_field(nframe, 'bcflag').astype(np.int16)
node32 = coord[(bcflag & 32).astype(bool)]
###### create new vertice #######
## extend two walls
xbtm = coord[bcflag == 17]
xbtm2 = [[xbtm[0, 0] - 10000, xbtm[0, 1]]]
xtop = coord[bcflag == 33]
xtop2 = [[xtop[0, 0] - 10000, xtop[0, 1]]]
x0 = np.vstack([xbtm, xbtm2, xtop, xtop2])
tridict = dict(vertices=x0)
B = tr.triangulate(tridict, 'qa1000000')
n0 = coord.shape[0]
coord = np.vstack([coord, B['vertices']])
conn = np.vstack([conn, B['triangles'] + n0])
rho = np.hstack([rho, np.ones(shape=B['triangles'].shape[0]) * 1750])
bcflag = np.hstack([bcflag, np.zeros(shape=B['vertices'].shape[0])
]).astype(np.int16)
xbtm = coord[bcflag == 66]
xbtm2 = [[xbtm[0, 0] + 10000, xbtm[0, 1]]]
xtop = coord[bcflag == 34]
xtop2 = [[xtop[0, 0] + 10000, xtop[0, 1]]]
x0 = np.vstack([xbtm, xbtm2, xtop, xtop2])
tridict = dict(vertices=x0)
B = tr.triangulate(tridict, 'qa1000000')
n0 = coord.shape[0]
coord = np.vstack([coord, B['vertices']])
conn = np.vstack([conn, B['triangles'] + n0])
rho = np.hstack([rho, np.ones(shape=B['triangles'].shape[0]) * 1750])
################################
measureX = np.arange(left, right, 500)
measureY = np.ones(shape=measureX.shape) * height
result = bouguer(measureX, measureY, coord, conn, rho) * 1e5
##### figure #####
fig, ax = plt.subplots(figsize=(10, 2.5))
ax.set_title(modelname)
ax.plot(measureX, result)
ax.set_ylabel('Bouguer gravity anomaly (mgal)(blue)')
ax2 = ax.twinx()
ax2.plot(node32[:, 0], node32[:, 1], 'r')
ax2.set_ylabel('topography (m)(red)')
# ax2.set_aspect('equal', adjustable="datalim")
plt.show()
def calculate():
print('Tapez Q pour quitter')
print(
'Je peut calculer l\'aire \n\n 1. rectangle \n\n 2. triangle \n\n 3. cercle'
)
choice = input('\nchoisi\n')
os.system('clear')
ready_to_quit(choice)
if choice == '1':
squared()
if choice == '2':
triangulate()
if choice == '3':
circulate()
def triMesh(self):
'''Method to generate a triangles mesh in a polygon by using
`Constrained Delaunay triangulation\
<https://en.wikipedia.org/wiki/Constrained_Delaunay_triangulation>`_.
Return:
verts ((n, 3, 2) `numpy.ndarray`): Vertices of each triangle that\
compose the triangular mesh. n means the number of triangles;\
(3, 2) means the index vertices and the coordinates (x, y)\
respectively.
Examples:
>>> from numpy import array
>>> from circpacker.basegeom import Polygon
>>> from circpacker.packer import CircPacking as cp
>>> coordinates = array([[1, 1], [2, 5], [4.5, 6], [6, 4], [8, 3],
[7, 1], [4.5, 1], [4, 0]])
>>> polygon = Polygon(coordinates)
>>> boundCoords = polygon.boundCoords
>>> circPack = cp(boundCoords, depth=8)
>>> verts = circPack.triMesh()
>>> from numpy import array
>>> from circpacker.basegeom import Polygon
>>> from circpacker.packer import CircPacking as cp
>>> coordinates = array([[2, 2], [2, 6], [8, 6], [8, 2]])
>>> polygon = Polygon(coordinates)
>>> boundCoords= polygon.boundCoords
>>> circPack = cp(boundCoords, depth=3)
>>> verts = circPack.triMesh()
'''
index = np.arange(len(self.coordinates[:-1]))
indexSegmts = np.column_stack((index, np.hstack((index[1:], [0]))))
# constrained Delaunay triangulation
if self.maxArea is None and self.minAngle is None:
self.CDT = triangulate(tri={'vertices': self.coordinates[:-1],
'segments': indexSegmts},
opts='pq25S15')
else:
self.CDT = triangulate(tri={'vertices': self.coordinates[:-1],
'segments': indexSegmts},
opts='pq'+str(self.minAngle)+'a' +
str(self.maxArea))
vertsIndex = self.CDT['vertices']
trianglesIndex = self.CDT['triangles']
verts = vertsIndex[trianglesIndex]
return verts
def main():
A = dict(vertices=np.array((
(0, 0),
(1, 0),
(1, 1),
(0.5, 0.5),
(0, 1),
)),
segments=[
(0, 1),
(1, 2),
(2, 3),
(3, 4),
(4, 0),
])
B = tr.triangulate(A, opts="pa0.03")
print(B)
print(len(B['vertices']))
print(len(B['vertex_markers']))
print(len(B['triangles']))
tr.compare(plt, A, B)
plt.savefig('tri.png')
def test_triangulate():
v = [[0, 0], [0, 1], [1, 1], [1, 0]]
t = triangulate({"vertices": v}, "a0.2")
assert np.allclose(
t["vertices"],
[
[0.0, 0.0],
[0.0, 1.0],
[1.0, 1.0],
[1.0, 0.0],
[0.5, 0.5],
[0.0, 0.5],
[0.5, 0.0],
[1.0, 0.5],
[0.5, 1.0],
],
)
assert np.allclose(
t["vertex_markers"],
[[1], [1], [1], [1], [0], [1], [1], [1], [1]],
)
assert np.allclose(
t["triangles"],
[
[7, 2, 4],
[5, 0, 4],
[4, 8, 1],
[4, 1, 5],
[4, 0, 6],
[6, 3, 4],
[4, 3, 7],
[4, 2, 8],
],
)
def generate_embossing(height):
embs = calc_embossing()
keys = ['vertex1','vertex2','vertex3']
for emb in embs:
segs = simple_segs(emb)
tri = triangle.triangulate({'vertices': np.array(emb),'segments' :segs }, 'pf' )
for trian in tri['triangles']:
point = {}
ref = 0
for vertex in trian:
point[keys[ref]] = [emb[vertex][X], emb[vertex][Y], height]
ref = ref + 1
object_data['points'].append(point)
for trian in tri['triangles']:
point = {}
ref = 0
for vertex in trian:
point[keys[ref]] = [emb[vertex][X], emb[vertex][Y], height+embossing_height]
ref = ref + 1
object_data['points'].append(point)
for vertex in emb:
vertex.append(height)
make_3d(emb,height,True)
def triangulate_regular_polygon(sides, radius, pos, size):
x, y = pos
angle = 2 * pi / sides
all_verts = []
all_verts_a = all_verts.append
r = radius
for s in range(sides):
new_pos = x + r * sin(s * angle), y + r * cos(s * angle)
all_verts_a(new_pos)
A = {'vertices':array(all_verts)}
command = 'cqa' + size + 'YY'
B = triangle.triangulate(A, command)
tri_indices = B['triangles']
new_indices = []
new_vertices = {}
tri_verts = B['vertices']
new_ex = new_indices.extend
ind_count = 0
for tri in tri_indices:
new_ex((tri[0], tri[1], tri[2]))
ind_count += 3
vert_count = 0
for i, tvert in enumerate(tri_verts):
new_vertices[i] = {
'pos': [tvert[0], tvert[1]],
'v_color': [255, 255, 255, 255]
}
vert_count += 1
return {'indices': new_indices, 'vertices': new_vertices,
'vert_count': vert_count, 'ind_count': ind_count}
def _triangulate_raster_from_file(self):
"""
Main function used to create the irregular TIN surface for Badlands based on
a regular DEM file.
"""
# Compute DEM edges
self._raster_edges()
# Compute TIN grid boundaries
self._TIN_ghosts_bounds()
# Create TIN
tinPts = numpy.vstack(( self.bounds, self.edges))
self.tinMesh = triangle.triangulate( dict(vertices=tinPts),'Dqa'+str(self.areaDel))
ptsTIN = self.tinMesh['vertices']
# Check extent
checkXmin = ptsTIN[self.boundsPt:,0].min()
checkXmax = ptsTIN[self.boundsPt:,0].max()
checkYmin = ptsTIN[self.boundsPt:,1].min()
checkYmax = ptsTIN[self.boundsPt:,1].max()
if checkXmin < self.rectX.min() or checkXmax > self.rectX.max():
raise ValueError('Error in defining the X boundary nodes, you will need to adjust the resolution value')
if checkYmin < self.rectY.min() or checkYmax > self.rectY.max():
raise ValueError('Error in defining the Y boundary nodes, you will need to adjust the resolution value')
# Add masks
self.bmask = numpy.zeros(len(ptsTIN[:,0]))
self.bmask[:self.boundsPt] = 1
return
def triangulate(P):
n = len(P)
S = np.repeat(np.arange(n + 1), 2)[1:-1]
S[-2:] = n - 1, 0
S = S.reshape((-1, 2))
T = triangle.triangulate({'vertices': P[:, :2], 'segments': S}, "p")
return T["triangles"].ravel()
def delaunay_triangulation(points):
"""Construct a Delaunay triangulation of set of vertices.
Parameters
----------
points : list
XY(Z) coordinates of the points to triangulate.
Returns
-------
tuple
* The vertices of the triangulation.
* The faces of the triangulation.
Examples
--------
>>>
References
----------
https://www.cs.cmu.edu/~quake/triangle.delaunay.html
"""
data = {'vertices': [point[0:2] for point in points]}
result = triangulate(data, opts='c')
vertices = [[x, y, 0] for x, y in result['vertices']]
faces = result['triangles']
return vertices, faces
def curve_to_mesh(self,curve):
M=len(curve)
segs = np.zeros((M,2)).astype(np.int32)
segs[:,0] = np.linspace(0,M-1,M).astype(np.int32)
segs[:,1] = segs[:,0]+1
segs[-1,-1] = 0
face={"vertices": np.array(curve).astype(np.float32),"segments": np.array(segs).astype(np.int32)}
tri = triangle.triangulate(face,'pq10')
verts_2d = tri["vertices"]
trinagles_2d = tri["triangles"]
verts = np.zeros((len(verts_2d),4),dtype=np.float32)
trinagles = np.zeros((len(trinagles_2d),3),dtype=np.float32)
verts[:,0] = verts_2d[:,0]
trinagles[:,0] = trinagles_2d[:,0]
verts[:,1] = verts_2d[:,1]
trinagles[:,1] = trinagles_2d[:,1]
trinagles[:,2] = trinagles_2d[:,2]
return GeoObject(verts=verts,tris=trinagles)
def obtainFullTria():
try:
a = 1
b = 1
# 预定义的格子店
x = np.array([0,-a,a,a,-a])
y = np.array([0,b,b,-b,-b])
grid4 = np.array([(xx,yy) for xx,yy in zip(x,y)])
edges = np.array([[0,1],[1,2],[2,0],\
[0,3],[3,4],[4,0]])
myPloy_with_grid = dict({'vertices':grid4,'segments':edges})
# 画出PLSG
plt.figure()
ax1 = plt.subplot(221, aspect='equal')
triplt.plot(ax1,**myPloy_with_grid)
# 进行网格剖分
myMesh_tria = triangle.triangulate(myPloy_with_grid,'pq30a0.01')
ax2 = plt.subplot(222, aspect='equal')
triplt.plot(ax2,**myMesh_tria)
plt.show()
return myMesh_tria
except Exception as e:
print e
def areaRefiner(this,model,norm):
X1 = 'X1'
X2 = 'Y1'
X3 = 'X2'
X4 = 'Y2'
X5 = 'X2'
X6 = 'Y3'
X7 = 'X4'
X8 = 'Y4'
X9 = 'X5'
X10 = 'Y5'
X11 = 'X6'
X12 = 'Y6'
X13 = 'CX'
X14 = 'CY'
X15 = 'XE1'
X16 = 'YE1'
X17 = 'XE2'
X18 = 'YE2'
X19 = 'XE3'
X20 = 'YE3'
X21 = 'CB'
dt = pd.DataFrame.from_records(this.generarDatos())
dt.columns = [X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14,X15,X16,X17,X18,X19,X20,X21]
xs = norm(dt)
ys = model(xs.values)
this.triangular['triangle_max_area'] = ys
tnueva = tr.triangulate(this.triangular,'ra')
tr.compare(plt,this.triangular,tnueva)
this.triangular = tnueva
this.diccionarios = this.triangular['triangles'].tolist()
this.tipos = np.zeros([len(this.diccionarios)]).astype(str)
this.tipos[:] = 'T1V'
this.gdls = this.triangular['vertices'].tolist()
this.cbe = this.generarCB(this.bordesCBE,this.valorCBE)
def __init__(this, vertices, params,cbe = [],valorCBE=10, plot=False):
this.bordesCBE = cbe
this.valorCBE= valorCBE
this.params = params
super().__init__(vertices)
this.seg = []
for i in range(len(this.vertices)-1):
this.seg.append([i,i+1])
this.seg.append([i+1,0])
this.original = dict(vertices=np.array(this.vertices),segments=np.array(this.seg))
this.triangular = tr.triangulate(this.original,this.params)
if plot:
tr.compare(plt, this.original, this.triangular)
count = 0
for i in this.triangular['segments']:
if count > 1:
if np.sum(np.isin(np.array(this.cbe)[:,0], i[0]))<1:
this.cbe.append([i[0],0])
if np.sum(np.isin(np.array(this.cbe)[:,0], i[1]))<1:
this.cbe.append([i[1],0])
else:
this.cbe.append([i[0],0])
if np.sum(np.isin(np.array(this.cbe)[:,0], i[1]))<1:
this.cbe.append([i[1],0])
count+=1
this.diccionarios = this.triangular['triangles'].tolist()
this.tipos = np.zeros([len(this.diccionarios)]).astype(str)
this.tipos[:] = 'T1V'
this.gdls = this.triangular['vertices'].tolist()
def create_collision_object_polygon(polygon,
params=None,
collision_object_func=None):
if len(polygon.vertices) == 3:
return pycrcc.Triangle(polygon.vertices[0][0], polygon.vertices[0][1],
polygon.vertices[1][0], polygon.vertices[1][1],
polygon.vertices[2][0], polygon.vertices[2][1])
else:
if all(np.equal(polygon.vertices[0], polygon.vertices[-1])):
vertices = polygon.vertices[:-1]
else:
vertices = polygon.vertices
number_of_vertices = len(vertices)
segments = list(
zip(range(0, number_of_vertices - 1), range(1,
number_of_vertices)))
segments.append((0, number_of_vertices - 1))
triangles = triangle.triangulate(
{
'vertices': vertices,
'segments': segments
}, opts='pqS2.4')
mesh = list()
for t in triangles['triangles']:
v0 = triangles['vertices'][t[0]]
v1 = triangles['vertices'][t[1]]
v2 = triangles['vertices'][t[2]]
mesh.append(
pycrcc.Triangle(v0[0], v0[1], v1[0], v1[1], v2[0], v2[1]))
return pycrcc.Polygon(polygon.vertices.tolist(), list(), mesh)
def triangulate_face(data):
"""Determines the triangulation of the face of a shape.
Parameters
----------
data : np.ndarray
Nx2 array of vertices of shape to be triangulated
Returns
-------
vertices : np.ndarray
Mx2 array vertices of the triangles.
triangles : np.ndarray
Px3 array of the indices of the vertices that will form the
triangles of the triangulation
"""
if triangulate is not None:
len_data = len(data)
edges = np.empty((len_data, 2), dtype=np.uint32)
edges[:, 0] = np.arange(len_data)
edges[:, 1] = np.arange(1, len_data + 1)
# connect last with first vertex
edges[-1, 1] = 0
res = triangulate(dict(vertices=data, segments=edges), "p")
vertices, triangles = res['vertices'], res['triangles']
else:
vertices, triangles = PolygonData(vertices=data).triangulate()
triangles = triangles.astype(np.uint32)
return vertices, triangles
def _triangulate_raster_from_file(self):
"""
Main function used to create the irregular TIN surface for Badlands based on
a regular DEM file.
"""
# Compute DEM edges
self._raster_edges()
# Compute TIN grid boundaries
self._TIN_ghosts_bounds()
# Create TIN
tinPts = numpy.vstack(( self.bounds, self.edges))
self.tinMesh = triangle.triangulate( dict(vertices=tinPts),'Dqa'+str(self.areaDel))
ptsTIN = self.tinMesh['vertices']
# Check extent
checkXmin = ptsTIN[self.boundsPt:,0].min()
checkXmax = ptsTIN[self.boundsPt:,0].max()
checkYmin = ptsTIN[self.boundsPt:,1].min()
checkYmax = ptsTIN[self.boundsPt:,1].max()
if checkXmin < self.rectX.min() or checkXmax > self.rectX.max():
raise ValueError('Error in defining the X boundary nodes, you will need to adjust the resolution value')
if checkYmin < self.rectY.min() or checkYmax > self.rectY.max():
raise ValueError('Error in defining the Y boundary nodes, you will need to adjust the resolution value')
# Add masks
self.bmask = numpy.zeros(len(ptsTIN[:,0]))
self.bmask[:self.boundsPt] = 1
return
def tess(polys, holes):
indices = {}
vertices = []
segments = []
for i, poly in enumerate(polys):
for v in poly:
assert isinstance(v, tuple)
if v not in indices:
pos = len(vertices)
indices[v] = pos
vertices.append(v)
for v0, v1 in doubles(poly):
# TODO: check for duplicate segment
index0 = indices[v0]
index1 = indices[v1]
segments.append((index0, index1))
A = dict(
vertices=vertices,
segments=segments,
)
if holes:
A['holes'] = holes
B = tr.triangulate(A, opts="pq")
return B, A
def __init__(this, vertices, params, plot=False,**kargs):
this.params = params
this.cbe = []
this.cbn = []
this.seg = []
for i in range(len(vertices)-1):
this.seg.append([i,i+1])
this.seg.append([i+1,0])
this.original = dict(vertices=np.array(vertices),segments=np.array(this.seg))
this.triangular = tr.triangulate(this.original,this.params)
diccionarios = this.triangular['triangles'].tolist()
tipos = np.zeros([len(diccionarios)]).astype(str)
if 'o2' in params:
tipos[:] = 'T2V'
else:
tipos[:] = 'T1V'
gdls = this.triangular['vertices'].tolist()
super().__init__(vertices,diccionarios,gdls,tipos,segmentos=this.seg)
if tipos[0] == 'T2V':
for dicc in this.diccionarios:
a1 = dicc[5]
a2 = dicc[3]
a3 = dicc[4]
dicc[3] = a1
dicc[4] = a2
dicc[5] = a3
if plot:
this.dibujarse(**kargs)
def triangleMesh(x,y,refinement):
domain = {'vertices':np.array([[0.,0.],[1.,0.],[x,y]]),'triangles':np.array([[0,1,2]])}
mesh = triangle.triangulate(domain, 'qa'+str(refinement))
return mesh
def _sludge_pattern(resolution=128):
"""Random sludge pattern at bottom of tank."""
x_pos = np.linspace(1, 25, num=resolution)
y_pos = .0625 * x_pos - 6.0625
y_pos[1:-1] += np.random.normal(loc=.25, scale=.1, size=resolution - 2)
vertices = np.zeros((2 * resolution, 3))
vertices[:, 0] = np.concatenate((x_pos, x_pos[::-1]))
vertices[:, 1] = np.concatenate((y_pos, y_pos[::-1]))
vertices[resolution:, 2] = resolution * [-.5]
vert_id = np.array(range(2 * resolution))
triags = tr.triangulate(
dict(vertices=vertices[:, [0, 2]],
segments=np.stack((vert_id, (vert_id + 1) % len(vert_id))).T),
'pq')
faces = triags['triangles']
sludge = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
for i, face in enumerate(faces):
for j in range(3):
sludge.vectors[i][j] = vertices[face[j], :]
sludge.save('../foam/sim/constant/triSurface/sludge.stl')
return True
def triangulate(P):
n = len(P)
S = np.repeat(np.arange(n+1),2)[1:-1]
S[-2:] = n-1,0
S = S.reshape((-1, 2))
T = triangle.triangulate({'vertices': P[:,:2], 'segments': S}, "p")
return T["triangles"].ravel()
def triangulate(self):
#create the data structure required by the triangle library
n = len(self.points)
points = self.points
edges = [[i, (i + 1) % n] for i in range(n)]
hole_pts = []
for hole in self.holes:
offset = len(points)
hn = len(hole.points)
edges += [[i + offset, ((i + 1) % n) + offset] for i in range(hn)]
points = np.concatenate((points, hole.points), axis=0)
hole_pts.append(hole.get_interior_point())
tri_dict = {'vertices': points, 'segments': edges}
if len(self.holes) > 0:
tri_dict['holes'] = hole_pts
#triangulate with the triangle library
assert len(
points
) > 2, 'Trying to triangulate fewer than 2 points: ' + str(self)
t = triangle.triangulate(tri_dict)
t_verts = t['vertices'].tolist()
tris = t['triangles'].tolist()
partition = [Poly(np.array([t_verts[vi] for vi in tr])) for tr in tris]
#remove triangles corresponding to holes/areas outside of the polygon
filtered = []
for poly in partition:
pt = poly.get_interior_point()
if self.contains_point(pt):
filtered.append(poly)
return filtered
def refineMesh(self, args):
"""
See the API <http://dzhelil.info/triangle> for information on optional arguments.
Common arguments (use any combination):
p - triangulates a Planar Straight Line Graph.
a - imposes a maximum area for each triangle.
q - quality mesh generation no angles smaller than specified degrees (default: 20).
c - encloses convex hull with line segments
"""
t = clock()
args = str(args) #ensure string
tri = triangle.triangulate(self.meshDict, args)
self.x = tri['vertices'][:, 0]
self.y = tri['vertices'][:, 1]
self.simplicies = tri['triangles']
self.centroids = (tri['vertices'][tri['triangles'][:, 0]] +
tri['vertices'][tri['triangles'][:, 1]] +
tri['vertices'][tri['triangles'][:, 2]]) / 3
self.bmask = self.boundary_mask(tri)
if self.verbose:
print " - Mesh refinement complete. %i vertices in %f secs with arguments '%s'" % (
len(tri['vertices']), clock() - t, args)
return
def draw_triangulated_regular_polygon(self, sides, radius, pos, octaves, persistance, scale, size):
x, y = pos
angle = 2 * pi / sides
all_verts = []
all_verts_a = all_verts.append
r = radius
for s in range(sides):
new_pos = x + r * sin(s * angle), y + r * cos(s * angle)
all_verts_a(new_pos)
A = {"vertices": array(all_verts)}
command = "cqa" + size + "YY"
B = triangle.triangulate(A, command)
tri_indices = B["triangles"]
new_triangles = []
new_vertices = []
tri_verts = B["vertices"]
nv_ap = new_vertices.append
new_ap = new_triangles.append
tri_count = 0
for tri in tri_indices:
new_ap((tri[0], tri[1], tri[2]))
tri_count += 1
vert_count = 0
for tvert in tri_verts:
nv_ap([tvert[0], tvert[1], octaves, persistance, scale])
vert_count += 1
return {
"triangles": new_triangles,
"vertices": new_vertices,
"vert_count": vert_count,
"tri_count": tri_count,
"vert_data_count": 5,
}
def triangulate_polygon(polygon, triangle_args=None, **kwargs):
"""
Given a shapely polygon create a triangulation using a
python interface to `triangle.c`:
> `pip install triangle`
Parameters
---------
polygon : Shapely.geometry.Polygon
Polygon object to be triangulated
triangle_args : str or None
Passed to triangle.triangulate i.e: 'p', 'pq30'
Returns
--------------
vertices : (n, 2) float
Points in space
faces : (n, 3) int
Index of vertices that make up triangles
"""
# do the import here for soft requirement
from triangle import triangulate
# set default triangulation arguments if not specified
if triangle_args is None:
triangle_args = 'p'
# turn the polygon in to vertices, segments, and hole points
arg = _polygon_to_kwargs(polygon)
# run the triangulation
result = triangulate(arg, triangle_args)
return result['vertices'], result['triangles']
def draw_triangulated_rectangle(self, width, height, pos, octaves, persistance, scale, size):
x, y = pos
all_verts = [(x, y), (x, y + height), (x + width, y + height), (x + width, y)]
A = {"vertices": array(all_verts)}
command = "cqa" + size
B = triangle.triangulate(A, command)
tri_indices = B["triangles"]
new_triangles = []
new_vertices = []
tri_verts = B["vertices"]
nv_ap = new_vertices.append
new_ap = new_triangles.append
tri_count = 0
for tri in tri_indices:
new_ap((tri[0], tri[1], tri[2]))
tri_count += 1
vert_count = 0
for tvert in tri_verts:
nv_ap([tvert[0], tvert[1], octaves, persistance, scale])
vert_count += 1
print vert_count, tri_count
return {
"triangles": new_triangles,
"vertices": new_vertices,
"vert_count": vert_count,
"tri_count": tri_count,
"vert_data_count": 5,
}
def calculate_mesh(a, bbox, target, get_t=False):
# FIXME target/get_t is ugly
"""triangulate a mesh based on a Planar Straight Line Graph with
mesh constraints. Return either the Delaunay triangulation or a
difference in number of triangles from a target.
Parameters
----------
a : float
global maximum triangular area constraint
bbox : dict
dictionary with keys vertices and segments representing PSLG
target : int
number of triangles to which the triangulation will be compared if
get_t is False
get_t : boolean
whether to return a Delaunay Triangulation rather than a
comparison to target
Returns
-------
val : scipy.spatial.Delaunay or int
Delaunay triangulation if get_t is True, otherwise the number of
vertices in the triangulation subtracted from the target
"""
t = triangle.triangulate(bbox, 'pqa%0.1f' % a)
if get_t:
# scipy.Delaunay has nice find_simplex method,
# but, no obvious way to iteratively refine meshes, like triangle
# numbering is different, so, switch here
return Delaunay(t['vertices'])
return target - len(t['vertices'])
def spherePolygon(mesh, points, radius=1, color=None):
offset = len(mesh.vertices)
if points[0][0] == points[-1][0]:
points.pop()
sphere_pts = []
for point in points:
sphere_pts.append(point)
v = toSphere(point, radius)
normal = normalize(v)
mesh.vertices_texcoords([.5 + point[0] / 360., .5 + point[1] / 180.])
# mesh.addNormal( normal )
mesh.addVertex(v)
if color:
mesh.addColor(color)
segments = []
for i in range(len(points)):
segments.append([i, (i + 1) % len(points)])
cndt = triangulate(dict(vertices=sphere_pts, segments=segments), 'p')
for face in cndt['triangles']:
mesh.addTriangle(offset + (face[0] % len(sphere_pts)),
offset + (face[1] % len(sphere_pts)),
offset + (face[2] % len(sphere_pts)))
offset += len(points)
return mesh
def getHolePoint(self, ring):
segments = []
vertmarks = []
segmarks = []
for i in range(len(ring) - 1):
segments.append([int(i), int(i + 1)])
vertmarks.append([0])
segmarks.append([0])
segments.append([int(i + 1), int(0)])
vertmarks.append([0])
segmarks.append([0])
pol = {
'vertices': ring,
'segments': segments,
'vertex_markers': vertmarks,
'segment_markers': segmarks
}
tris = triangle.triangulate(pol, opts="p")
tri = tris['triangles'][0]
v = tris['vertices']
# De gemiddelde waarde van de coordinaten van een driehoek ligt altijd binnen de driehoek
a = v[tri[0]]
b = v[tri[1]]
c = v[tri[2]]
return [(a[0] + b[0] + c[0]) / 3, (a[1] + b[1] + c[1]) / 3]
def _triangulate_cpp(vertices_2d, segments):
import triangle
T = triangle.triangulate({'vertices': vertices_2d,
'segments': segments}, "p")
vertices_2d = T["vertices"]
triangles = T["triangles"]
return vertices_2d, triangles
def STLWrite(faces, filename, thickness=0):
import triangle
shape = None
shells = []
triangles = []
for f in faces:
r = f[0]
A = f[1]
facets = []
B = triangle.triangulate(A, opts='p')
if not 'triangles' in B:
print "No triangles in " + B
continue
if thickness:
for t in [np.transpose(np.array([list(B['vertices'][x]) + [0,1] for x in (face[0], face[1], face[2])])) for face in B['triangles']]:
facets.extend([np.dot(r, x) for x in inflate(t, thickness=thickness)])
for t in [np.transpose(np.array([list(A['vertices'][x]) + [0,1] for x in (edge[0], edge[1])])) for edge in A['segments']]:
facets.extend([np.dot(r, x) for x in inflate(t, thickness=thickness, edges=True)])
else:
for t in [np.transpose(np.array([list(B['vertices'][x]) + [0,1] for x in (face[0], face[1], face[2])])) for face in B['triangles']]:
facets.append(np.dot(r, t))
triangles.extend(facets)
if thickness:
FREECADPATH = '/usr/lib64/freecad/lib'
import sys
sys.path.append(FREECADPATH)
import FreeCAD
import Part
meshes = []
for f in (np.transpose(t[0:3,:]) for t in facets):
try:
meshes.append(Part.Face(Part.Wire([Part.makeLine(tuple(f[x]), tuple(f[x-1])) for x in range(3)])))
except RuntimeError:
print "Skipping face: " + repr(f)
shell = Part.makeShell(meshes)
shells.append(shell)
if shape is None:
shape = shell
else:
shape = shape.fuse(shell)
if shape:
with open("freecad" + filename, 'wb') as fp:
shape.exportStl("freecad" + filename)
from stlwriter import Binary_STL_Writer
faces = triangles
with open(filename, 'wb') as fp:
writer = Binary_STL_Writer(fp)
writer.add_faces(faces)
writer.close()
def triangulate(geometry, max_area=None):
"""Use the triangle library to triangulate a polygon
Args:
polygon (shapely.*): shapely geometry representing the area to
triangulate
max_area (float): If provided, the triangulation will be refined
until all triangles have area less than this maximum.
Returns:
list: list of triangular polygons
"""
if not geometry.is_valid:
raise ValueError("Tried to triangulate invalid geometry", geometry)
if hasattr(geometry, "geoms"): # polygon is a MultiPolygon
polygons = list(geometry.geoms)
else:
polygons = [geometry]
vertices = []
segments = []
for polygon in polygons:
offset = len(vertices)
vertices.extend(polygon.exterior.coords[0:-1])
segments.extend(circular_pairs(
range(offset, offset+len(polygon.exterior.coords)-1)))
for ring in polygon.interiors:
offset = len(vertices)
vertices.extend(ring.coords[0:-1])
segments.extend(circular_pairs(
range(offset, offset+len(ring.coords)-1)))
shape = {'vertices': numpy.array(vertices),
'segments': numpy.array(segments, dtype=numpy.int32)}
# Find the holes in the geometry
buffer_by = numpy.sqrt(geometry.envelope.area)
complement = geometry.envelope.buffer(
buffer_by, cap_style=2, join_style=2).difference(geometry)
if complement.geom_type == "MultiPolygon":
shape['holes'] = numpy.array([interior.representative_point().coords[0]
for interior in complement.geoms])
elif complement.geom_type == "Polygon":
shape['holes'] = numpy.array(complement.representative_point().coords[0])
if max_area is None:
opts = "p"
else:
opts = "pa{}".format(max_area)
triangulation = triangle.triangulate(shape, opts)
return [shapely.geometry.Polygon([triangulation['vertices'][i]
for i in triplet])
for triplet in triangulation['triangles']]
def cycles2triangles(polygon):
triangleSet = []
vertices = []
stringVertices = set()
for cycle in polygon:
for vertex in cycle:
stringVertex = str(vertex)
if (stringVertex not in stringVertices):
vertices.append(vertex)
stringVertices.add(stringVertex)
edges = []
externalCycle = polygon[0]
edges += face2edge([[vertices.index(vertex) for vertex in externalCycle]])
holeEdges = []
holeInnerPoints = []
internalCycles = polygon[1:]
for hole in internalCycles:
holeEdges += face2edge([[vertices.index(vertex) for vertex in hole]])
holeInnerPoints.append(internalTo(hole,holeEdges))
edges += holeEdges
if holeInnerPoints != []:
triangulation = triangulate({"vertices":vertices,"segments":edges,"holes":holeInnerPoints},'p')
else:
triangulation = triangulate({"vertices": vertices, "segments": edges}, 'p')
vertices = triangulation['vertices'].tolist()
triangles = triangulation['triangles'].tolist()
trias = [[vertices[index] for index in triangle] for triangle in triangles]
trias = [[[vertex[0], vertex[1], 0.0] for vertex in tri] for tri in trias]
triangleSet += [trias]
return triangleSet
def RMS_calc(lons,lats,rotation):
#Define an equal area projection around the plate
m = pyproj.Proj("+proj=aea +lat_1="+`min(lats)`+" +lat_2="+`max(lats)`+" +lat_0="+`(min(lats)+max(lats))/2`+" +lon_0="+`(min(lons)+max(lons))/2`)
#Create irregular triangular mesh for the plate polygon
data={}
data['vertices']=np.column_stack((lons,lats))
segs=[[0,len(lons)-1]]
for i in np.arange(0,len(lons)-1): segs.append([i,i+1])
data['segments']=np.array(segs)
t = triangulate(data, 'pa50q30') #starting off with too small an area can cause crashes
#can refine further using r switch - note I do so right now but the difference in the overall result is small
t2= triangulate(t, 'ra10q30')
f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)
tplot.plot(ax1, **t)
plt.title('1st Triangulation - min area 50, min angle 30')
tplot.plot(ax2, **t2)
plt.title('Refined mesh - min area 10, min angle 30')
plt.tight_layout()
units=t2['vertices'][t2['triangles']]
vel_lat,vel_lon,vel_mag,vel_az= [],[],[],[]
totvelsquared=0.
totarea=0.
for unit in units:
tlon,tlat=m(unit[:,0],unit[:,1])
thing=Polygon(np.column_stack((tlon,tlat)))
area=thing.area/1e6
x,y=thing.centroid.xy
x,y=m(x,y,inverse=True)
platevel=get_plate_velocity(([y[0],x[0]]),rotation)
totvelsquared=totvelsquared+(area*platevel[0]**2)
totarea=totarea+area
vel_lon.append(x)
vel_lat.append(y)
vel_mag.append(platevel[0])
vel_az.append(platevel[1])
rms=np.sqrt(totvelsquared/totarea)
velgrid=pd.DataFrame(np.column_stack((vel_lon,vel_lat,vel_mag,vel_az)), columns=['Lons','Lats','Rate','Azimuth'])
return rms, totarea, velgrid
def foo3():
import triangle
import triangle.plot as plot
node_list, crease_list, crease_types = load_creasepattern('test.creasepattern')
#print node_list
#print crease_list
paper = {}
paper['vertices'] = node_list
paper['segments'] = crease_list
ax1 = mpl.subplot(121, aspect='equal')
plot.plot(ax1, **paper)
t = triangle.triangulate(paper, 'p')
print t
ax2 = mpl.subplot(122, sharex=ax1, sharey=ax1)
plot.plot(ax2, **t)
nodes = t['vertices']
triangles = t['triangles']
#offset = 0.01
for i in range(triangles.shape[0]):
mean_x = np.mean(nodes[triangles[i,:],0])
mean_y = np.mean(nodes[triangles[i,:],1])
mpl.text(mean_x, mean_y, '%d' % i)
edge2triangle = get_edge2triangle(t['triangles'])
print 'edge2triangle'
print edge2triangle
neighbors, neighbor_angles = get_neighbors(node_list, crease_list)
i = 4
angle = 15
crease_angles = [angle, 180, angle, None, angle, 180, angle, None]
ans = solve_node(neighbor_angles[i], crease_angles)
crease_angles = ans[0]
known_creases = {}
known_creases = add_node_creases(known_creases, i, neighbors[i], crease_angles)
known_creases = add_flat_creases(known_creases, triangles)
print known_creases
frames, nodes3d = propagate_frames(nodes, triangles, known_creases, triangle_index=0)
for i, n in enumerate(nodes3d):
print i, n
plot_creasepattern(nodes, crease_list, crease_types=crease_types, triangles=triangles)
def Triangulate(self):
delaunay = triangle.triangulate({'vertices' : self.vertices})
self.segments_vertices = {}
self.vertices_segments = {}
self.delaunay_triangles = {}
for tri in delaunay['triangles']:
for ind in range(3):
a, b, c = tri[ind], tri[(ind + 1) % 3], tri[(ind + 2) % 3]
self.InsertSegments_Vertices(a, b, c)
self.InsertVertices_Segments(a, b, c)
for tri in delaunay['triangles']:
a, b, c = sorted((tri[0], tri[1], tri[2]))
self.delaunay_triangles[(a, b, c)] = True
def triangulate(vertices):
n = len(vertices)
vertices = np.array(vertices)
zmean = vertices[:,2].mean()
vertices_2d = vertices[:,:2]
segments = np.repeat(np.arange(n+1),2)[1:-1]
segments[-2:] = n-1,0
T = triangle.triangulate({'vertices': vertices_2d,
'segments': segments}, "p")
vertices_2d = T["vertices"]
triangles = T["triangles"]
vertices = np.empty((len(vertices_2d),3))
vertices[:,:2] = vertices_2d
vertices[:,2] = zmean
return vertices, triangles
def foo2():
# From http://dzhelil.info/triangle/delaunay.html
# (not my code)
import triangle
import triangle.plot as plot
face = triangle.get_data('face')
print face
ax1 = mpl.subplot(121, aspect='equal')
plot.plot(ax1, **face)
t = triangle.triangulate(face, 'p')
ax2 = mpl.subplot(122, sharex=ax1, sharey=ax1)
triangle.plot.plot(ax2, **t)
mpl.show()
def triangulate(polygon):
"""
Triangulates 3D polygons
"""
vect1 = [polygon[1][0] - polygon[0][0],
polygon[1][1] - polygon[0][1],
polygon[1][2] - polygon[0][2]]
vect2 = [polygon[2][0] - polygon[0][0],
polygon[2][1] - polygon[0][1],
polygon[2][2] - polygon[0][2]]
vectProd = [vect1[1] * vect2[2] - vect1[2] * vect2[1],
vect1[2] * vect2[0] - vect1[0] * vect2[2],
vect1[0] * vect2[1] - vect1[1] * vect2[0]]
polygon2D = []
segments = list(range(len(polygon)))
segments.append(0)
# triangulation of the polygon projected on planes (xy) (zx) or (yz)
if(math.fabs(vectProd[0]) > math.fabs(vectProd[1]) and math.fabs(vectProd[0]) > math.fabs(vectProd[2])):
# (yz) projection
for v in range(0,len(polygon)):
polygon2D.append([polygon[v][1], polygon[v][2]])
elif(math.fabs(vectProd[1]) > math.fabs(vectProd[2])):
# (zx) projection
for v in range(0,len(polygon)):
polygon2D.append([polygon[v][0], polygon[v][2]])
else:
# (xy) projextion
for v in range(0,len(polygon)):
polygon2D.append([polygon[v][0], polygon[v][1]])
triangulation = triangle.triangulate({'vertices': polygon2D, 'segments': segments})
if 'triangles' not in triangulation: # if polygon is degenerate
return []
trianglesIdx = triangulation['triangles']
triangles = []
for t in trianglesIdx:
# triangulation may break triangle orientation, test it before adding triangles
if(t[0] > t[1] > t[2] or t[2] > t[0] > t[1] or t[1] > t[2] > t[0]):
triangles.append([polygon[t[1]], polygon[t[0]],polygon[t[2]]])
else:
triangles.append([polygon[t[0]], polygon[t[1]],polygon[t[2]]])
return triangles
def triangulate(game_objects, scenario_width, scenario_height):
points = []
segments = []
holes = []
for obj in game_objects:
if obj.getRole() == GOBJ.MAN:
continue
offset = len(points)
vertices = obj.getPosScr()
points = points + vertices
#if obj.getRole() == GOBJ.IMMOVEABLE:
hole = ((vertices[0][0] + vertices[2][0])/2, (vertices[0][1] + vertices[2][1])/2)
holes.append(hole)
edges = obj.getEdges()
edges = [ [edge[0] + offset, edge[1] + offset] for edge in edges]
segments = segments + edges
## add frames
points = points + [[0,0],[0,scenario_height],[scenario_width,scenario_height],[scenario_width,0]]
points = np.array(points)
segments = np.array(segments)
holes = np.array(holes)
dic = {}
dic["vertices"] = points
dic["segments"] = segments
dic["holes"] = holes
tri = triangle.triangulate(dic,'pc')
zones = [Polygon(tri["vertices"][t]) for t in tri["triangles"]]
graph = createGraph(tri["triangles"], tri["vertices"], tri["segments"])
#graph = create_graph_advanced(tri["triangles"], tri["vertices"], tri["segments"])
return graph, zones
def refineMesh(self, args): """ See the API <http://dzhelil.info/triangle> for information on optional arguments. Common arguments (use any combination): p - triangulates a Planar Straight Line Graph. a - imposes a maximum area for each triangle. q - quality mesh generation no angles smaller than specified degrees (default: 20). c - encloses convex hull with line segments """ t = clock() args = str(args) #ensure string tri = triangle.triangulate(self.meshDict, args) self.x = tri['vertices'][:,0] self.y = tri['vertices'][:,1] self.simplicies = tri['triangles'] self.centroids = (tri['vertices'][tri['triangles'][:,0]] + tri['vertices'][tri['triangles'][:,1]] + tri['vertices'][tri['triangles'][:,2]])/3 self.bmask = self.boundary_mask(tri) if self.verbose: print " - Mesh refinement complete. %i vertices in %f secs with arguments '%s'" % (len(tri['vertices']), clock()-t, args) return
def triangulatePolygon(self, poly):
poly = self.stripLastCoordinate(poly)
segments = []
vertmarks = []
segmarks = []
holes = []
c = 0
for p in range(len(poly)):
for i in range(len(poly[p]) - 1):
segments.append([int(c+i), int(c+i+1)])
segments.append([int(c+i+1),int(c)])
c = len(segments)
# Vertex en segment markers
# Nummer bij vertexes en segments moet overeen komen
for i in range(len(poly[p])):
vertmarks.append([p])
segmarks.append([p])
if p > 0:
# Gat
holes.append(self.getHolePoint(poly[p]))
allverts = list(itertools.chain.from_iterable(poly))
if len(holes) > 0:
pol = {'vertices': allverts, 'segments': segments, 'vertex_markers': vertmarks, 'segment_markers': segmarks, 'holes': holes}
else:
pol = {'vertices': allverts, 'segments': segments, 'vertex_markers': vertmarks, 'segment_markers': segmarks}
result = triangle.triangulate(pol, opts="p")
result['triangles'] = self.correctTriangles(result['triangles'], result['vertices'])
result['segments'] = self.correctSegments(result['segments'])
return result
def getHolePoint(self, ring):
segments = []
vertmarks = []
segmarks = []
for i in range(len(ring) - 1):
segments.append([int(i), int(i+1)])
vertmarks.append([0])
segmarks.append([0])
segments.append([int(i+1),int(0)])
vertmarks.append([0])
segmarks.append([0])
pol = {'vertices': ring, 'segments': segments, 'vertex_markers': vertmarks, 'segment_markers': segmarks}
tris = triangle.triangulate(pol, opts="p")
tri = tris['triangles'][0]
v = tris['vertices']
# De gemiddelde waarde van de coordinaten van een driehoek ligt altijd binnen de driehoek
a = v[tri[0]]
b = v[tri[1]]
c = v[tri[2]]
return [(a[0]+b[0]+c[0])/3,(a[1]+b[1]+c[1])/3]
import triangle
import triangle.plot as plot
import matplotlib.pyplot as plt
face = triangle.get_data('face')
ax1 = plt.subplot(121, aspect='equal')
plot.plot(ax1, **face)
t = triangle.triangulate(face, 'pq10')
ax2 = plt.subplot(122, sharex=ax1, sharey=ax1)
plot.plot(ax2, **t)
plt.show()
import matplotlib.pyplot as plt
import triangle
import triangle.plot
spiral = triangle.get_data("spiral")
t = triangle.triangulate(spiral, "a.2")
ax1 = plt.subplot(111, aspect="equal")
triangle.plot.plot(ax1, **t)
plt.show()
vertices = [(0,0), (12,0), (12,8), (0,8), (1,1), (3,1), (3,3), (1,3), (4,2), (10,2),
(10,3), (4,3), (2,4), (7,4), (7,6), (2,6), (8,5), (11,5), (11,7), (8,7),
(6,3.5)]
segments = [(0,1), (1,2), (2,3), (3,0), (4,5), (5,6), (6,7), (7,4), (8,9), (9,10),
(10,11), (11,8), (12,13), (13,14), (14,15), (15,12), (16,17), (17,18),
(18,19), (19,16)]
holes = [(2,2), (7,2.5), (10,6), (4,5)]
room = {}
room['vertices'] = array(vertices)
room['segments'] = array(segments)
room['holes'] = array(holes)
tri = triangulate(room, 'pq20a0.1D')
X = tri['triangles'][:,0]
Y = tri['triangles'][:,1]
Z = tri['triangles'][:,2]
Xvert = [tri['vertices'][x] for x in X]
Yvert = [tri['vertices'][x] for x in Y]
Zvert = [tri['vertices'][x] for x in Z]
dataXY = minkowski_distance(Xvert, Yvert)
dataXZ = minkowski_distance(Xvert, Zvert)
dataYZ = minkowski_distance(Yvert, Zvert)
nvert = len(tri['vertices'])
G = lil_matrix((nvert, nvert))
for k in range(len(X)):
G[X[k], Y[k]] = G[Y[k], X[k]] = dataXY[k]
G[X[k], Z[k]] = G[Z[k], X[k]] = dataXZ[k]
def triangulate(self):
return triangulate(self.triangle_data, 'p')
def triangulate(q, dic):
tri = triangle.triangulate(dic, 'pc')
#q.put(tri)
q.send(tri)
q.close()
def triangulate(points_array):
input_dict = dict(vertices=np.array(points_array), segments=ccw_segments(points_array))
tri = triangle.triangulate(input_dict, 'p')
return {'original':input_dict, 'tri':tri}
def _triangulate_cpp(vertices_2d, segments):
T = triangle.triangulate({'vertices': vertices_2d,
'segments': segments}, "p")
vertices_2d = T["vertices"]
triangles = T["triangles"]
return vertices_2d, triangles
import triangle import triangle.plot from numpy import * import matplotlib.pyplot as plt A = dict(vertices=array(((0,0), (1,0), (1, 1), (0, 1)))) B = triangle.triangulate(A, 'qa0.1') triangle.plot.compare(plt, A, B) plt.show()
