def triang_export(path_to_ocean_scale,polygon_nu):
""" Parameters:
path_to_ocean_scale:File name or path to IHO World Seas shapefile as
distributed in marineregions.org by Flanders Marine Institute. No
direct download is permitted as per License, hence no direct
availability through code.
Download the latest shapefile and use as input for this code.
polygon_nu: Integer
The polygon number as defined in the IHO World Seas
Shapefile from 0 to 21.
Returns:
File of Numpy Arrays that includes an array of the
points and an array of the point combinations by index, that creates
every triangle mesh.
Description:
1. A shapefile with the IHO world seas polygons is read.
2. An individual polygon from the former shapefile is used as basis
for the creation of an exterior linering and facets .
(order of linereings connection) that serves as input for
meshpy.triangle.
3. Meshpy triangle result (points,facets) given as numpy arrays
4. Refinement of meshpy triangles into 4 subdivisions for every
triangle taking the former point results.
5.Values exported as numpy files with the number of the polygon as
the name.
"""
gdf=gpd.read_file("{}.shp".format(path_to_ocean_scale))
polygon=gdf.geometry.iloc[polygon_nu]
linering=list(polygon.exterior.coords)
facets=round_trip_connect(0,len(linering)-1)
info=triangle.MeshInfo()
info.set_points(linering)
info.set_facets(facets)
mesh=triangle.build(info,max_volume=0.2,min_angle=30)
mesh_points=np.array(mesh.points)
mesh_facets=np.array(mesh.facets)
sub=triangle.subdivide_facets(4,mesh_points.tolist(),mesh_facets.tolist())
sub_points=np.array(sub[0])
sub_facets=np.array(sub[1])
info.set_points(sub_points)
info.set_facets(sub_facets)
mesh2=triangle.build(info,max_volume=0.5,min_angle=30)
mesh_points2=np.array(mesh2.points)
mesh_tris2=np.array(mesh2.elements)
np.savez("{}.npz".format(polygon_nu),mesh_points2,mesh_tris2)
def generate_mesh(self, max_volume=None):
info = triangle.MeshInfo()
info.set_points(self.vertices)
info.set_facets(round_trip_connect(0, len(self.vertices) - 1))
if max_volume:
self.mesh = triangle.build(info,
max_volume=max_volume,
min_angle=25)
else:
self.mesh = triangle.build(info, min_angle=25)
def test_point_attributes():
import meshpy.triangle as triangle
points = [(1, 1), (-1, 1), (-1, -1), (1, -1)]
info = triangle.MeshInfo()
info.set_points(points)
info.number_of_point_attributes = 2
info.point_attributes.setup()
for i in range(len(points)):
info.point_attributes[i] = [0, 0]
triangle.build(info)
def meshpy(self):
# Call meshpy and create the delaunay triangulation.
def centroid(vs):
return np.mean(vs, axis = 0)
def distance_to_boundary(pt):
d, l = self.kdtree.query([pt[0] / self.xy_scaling, pt[1]], k = 1)
return d
def refine_func(vertices, area):
center = centroid(vertices)
d_bndry = distance_to_boundary(center)
return bool(area > min(self.refine_area, d_bndry * self.near_edge_factor))
info = triangle.MeshInfo()
# Enter triangulation coordinates (so that delaunay angles are
# reasonable) by multiplying by xy_scaling
internal_points = map(lambda x: (x[0] * self.xy_scaling, x[1]),
copy(self.meshpy_vs))
info.set_points(internal_points)
info.set_facets(self.meshpy_es, facet_markers = self.meshpy_markers)
mesh = triangle.build(info,
refinement_func = refine_func,
generate_faces = True)
self.meshpy = mesh
self.meshpy_pts = np.array(mesh.points)
# Exit triangulation coordinates
self.meshpy_pts[:, 0] /= self.xy_scaling
self.meshpy_tris = np.array(mesh.elements, dtype = np.int)
def buildMesh(geometry, algorithm="EasyMesh", triangleAngle=0, triangleArea=0):
if algorithm=="EasyMesh":
tempFileFD, tempFileName = tempfile.mkstemp(suffix=".d", text=True)
tempFileBaseName, tempFileExtension = os.path.splitext(tempFileName)
writeEasyMeshInput(geometry, tempFileName)
runEasyMesh(tempFileName)
mesh = readEasyMeshOutput(tempFileBaseName)
return mesh
elif algorithm=="Triangle":
import meshpy.triangle as tri
info = tri.MeshInfo()
info.set_points(geometry.nodesList())
info.set_facets(geometry.asNodeIndices())
info.regions.resize(len(geometry.regions))
for i,region in enumerate(geometry.regions):
info.regions[i] = list(region)
if len(info.regions)>0:
volConstraints=True
triangleArea=0
else:
volConstraints=False
triMesh = tri.build(info,min_angle=triangleAngle, max_volume=triangleArea, attributes=True,
volume_constraints=volConstraints)
mesh = triangleMesh()
mesh.nodes.coordinates = np.array(triMesh.points)
mesh.nodes.numbers = range(len(mesh.nodes.coordinates))
mesh.elements.nodes = np.array(triMesh.elements)
mesh.elements.numbers = range(len(mesh.elements.nodes))
mesh.elements.markers = [1]*len(mesh.elements.nodes)
return mesh
elif algorithm=="Netgen":
tempFileFD, tempFileName = tempfile.mkstemp(suffix=".in2d", text=True)
writeNetgenInput(geometry, tempFileName)
mesh = runNetgen(tempFileName)
return mesh
def main():
points = [(1, 0), (1, 1), (-1, 1), (-1, -1), (1, -1), (1, 0)]
facets = round_trip_connect(0, len(points)-1)
circ_start = len(points)
points.extend(
(3 * np.cos(angle), 3 * np.sin(angle))
for angle in np.linspace(0, 2*np.pi, 30, endpoint=False))
facets.extend(round_trip_connect(circ_start, len(points)-1))
def needs_refinement(vertices, area):
bary = np.sum(np.array(vertices), axis=0)/3
max_area = 0.001 + (la.norm(bary, np.inf)-1)*0.01
return bool(area > max_area)
info = triangle.MeshInfo()
info.set_points(points)
info.set_holes([(0, 0)])
info.set_facets(facets)
mesh = triangle.build(info, refinement_func=needs_refinement)
mesh_points = np.array(mesh.points)
mesh_tris = np.array(mesh.elements)
import matplotlib.pyplot as pt
pt.triplot(mesh_points[:, 0], mesh_points[:, 1], mesh_tris)
pt.show()
def create_hole_mesh(num_unknowns):
def round_trip_connect(start, end):
return [(i, i + 1) for i in range(start, end)] + [(end, start)]
points = [(1 / 4, 0), (1 / 4, 1 / 4), (-1 / 4, 1 / 4), (-1 / 4, -1 / 4),
(1 / 4, -1 / 4), (1 / 4, 0)]
facets = round_trip_connect(0, len(points) - 1)
circ_start = len(points)
points.extend((1.5 * np.cos(angle), 1.5 * np.sin(angle))
for angle in np.linspace(0, 2 * np.pi, 30, endpoint=False))
facets.extend(round_trip_connect(circ_start, len(points) - 1))
maximum_area = 0.5 / num_unknowns
def needs_refinement(vertices, area):
bary = np.sum(np.array(vertices), axis=0) / 3
max_area = maximum_area + (np.linalg.norm(bary, np.inf) -
1 / 4) * maximum_area * 10
return bool(area > max_area)
info = triangle.MeshInfo()
info.set_points(points)
info.set_holes([(0, 0)])
info.set_facets(facets)
mesh = triangle.build(info, refinement_func=needs_refinement)
return mesh
def main():
import meshpy.triangle as triangle
info = triangle.MeshInfo()
info.set_points([ (1.5,1),(-1.2,1),(-1,-1),(1,-1)])
info.set_facets([(0, 1), (1, 2), (2, 3), (3, 0)])
mesh = triangle.build(info, max_volume=1e-3, min_angle=25)
print """
<?xml version="1.0" encoding="UTF-8"?>
<dolfin xmlns:dolfin="http://www.fenics.org/dolfin/">
<mesh celltype="triangle" dim="2">
<vertices size="%d">
""" % len(mesh.points)
for i, pt in enumerate(mesh.points):
print '<vertex index="%d" x="%g" y="%g"/>' % (
i, pt[0], pt[1])
print """
</vertices>
<cells size="%d">
""" % len(mesh.elements)
for i, element in enumerate(mesh.elements):
print '<triangle index="%d" v0="%d" v1="%d" v2="%d"/>' % (
i, element[0], element[1], element[2])
print """
def make_rect_mesh_with_corner(a=(0,0), b=(1,1), max_area=None,
boundary_tagger=(lambda fvi, el, fn, all_v: []),
corner_fraction=(0.3, 0.3),
refine_func=None):
"""Create an unstructured rectangular mesh with a reentrant
corner at (-x, -y).
:param a: the lower left hand point of the rectangle
:param b: the upper right hand point of the rectangle
:param max_area: maximum area of each triangle.
:param refine_func: A refinement function as taken by :func:`meshpy.triangle.build`.
:param corner_fraction: Tuple of fraction of the width taken up by
the rentrant corner.
"""
if max_area is not None:
if refine_func is not None:
raise ValueError, "cannot specify both refine_func and max_area"
def refine_func(vertices, area):
return area > max_area
marker2tag = {
1: "minus_x",
2: "minus_y",
3: "plus_x",
4: "plus_y",
4: "plus_y",
5: "corner_plus_y",
6: "corner_plus_x",
}
a = numpy.asarray(a)
b = numpy.asarray(b)
diag = b-a
w = diag.copy(); w[1] = 0
h = diag.copy(); h[0] = 0
points = [
a+h*corner_fraction[1],
a+h*corner_fraction[1]+w*corner_fraction[0],
a+w*corner_fraction[0],
a+w,
a+w+h,
a+h,
]
facets = list(_round_trip_connect(0, 5))
facet_markers = [5,6,2,3,4,1]
import meshpy.triangle as triangle
mesh_info = triangle.MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets(facets, facet_markers)
generated_mesh = triangle.build(mesh_info,
refinement_func=refine_func)
from hedge.mesh import make_conformal_mesh
return make_conformal_mesh(
generated_mesh.points,
generated_mesh.elements,
boundary_tagger)
def main():
import meshpy.triangle as triangle
import numpy as np
points = [(1, 1), (-1, 1), (-1, -1), (1, -1)]
for pt in np.random.randn(100, 2):
points.append(pt * 0.1)
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i + 1))
result.append((end, start))
return result
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(round_trip_connect(0, 3))
mesh = triangle.build(
info, allow_volume_steiner=False, allow_boundary_steiner=False
)
triangle.write_gnuplot_mesh("triangles.dat", mesh)
def main():
points = [(1, 0), (1, 1), (-1, 1), (-1, -1), (1, -1), (1, 0)]
facets = round_trip_connect(0, len(points) - 1)
circ_start = len(points)
points.extend((3 * np.cos(angle), 3 * np.sin(angle))
for angle in np.linspace(0, 2 * np.pi, 30, endpoint=False))
facets.extend(round_trip_connect(circ_start, len(points) - 1))
def needs_refinement(vertices, area):
bary = np.sum(np.array(vertices), axis=0) / 3
max_area = 0.001 + (la.norm(bary, np.inf) - 1) * 0.01
return bool(area > max_area)
info = triangle.MeshInfo()
info.set_points(points)
info.set_holes([(0, 0)])
info.set_facets(facets)
mesh = triangle.build(info, refinement_func=needs_refinement)
mesh_points = np.array(mesh.points)
mesh_tris = np.array(mesh.elements)
import matplotlib.pyplot as pt
pt.triplot(mesh_points[:, 0], mesh_points[:, 1], mesh_tris)
pt.show()
def main():
import meshpy.triangle as triangle
import math
import pickle
segments = 50
points = [(-5, -1), (-1, -1), (0, -1), (0, 0), (1, 0), (5, 0), (5, 1),
(1, 1), (-1, 1), (-5, 1)]
def round_trip_connect(seq):
result = []
for i in range(len(seq)):
result.append((seq[i], seq[(i + 1) % len(seq)]))
return result
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(
round_trip_connect([0, 1, 8, 9]) +
round_trip_connect([1, 2, 3, 4, 7, 8]) +
round_trip_connect([4, 5, 6, 7]))
info.regions.resize(3)
info.regions[0] = (-2, 0, 1, 0.1)
info.regions[1] = (-0.5, 0, 0, 0.01)
info.regions[2] = (1.5, 0.5, 1, 0.1)
mesh = triangle.build(info)
triangle.write_gnuplot_mesh("triangles.dat", mesh)
mesh.write_neu(open("tri_pml.neu", "w"))
def main():
import meshpy.triangle as triangle
import math
points = [ (1,1),(-1,1),(-1,-1),(1,-1) ]
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i+1))
result.append((end, start))
return result
def needs_refinement(vertices, area ):
vert_origin, vert_destination, vert_apex = vertices
bary_x = (vert_origin.x + vert_destination.x + vert_apex.x) / 3
bary_y = (vert_origin.y + vert_destination.y + vert_apex.y) / 3
dist_center = math.sqrt( (bary_x-1)**2 + (bary_y-1)**2 )
max_area = math.fabs( 0.05 * (dist_center-0.5) ) + 0.01
return area > max_area
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(round_trip_connect(0, len(points)-1))
mesh = triangle.build(info, refinement_func=needs_refinement)
mesh.write_neu(open("nico.neu", "w"))
triangle.write_gnuplot_mesh("triangles.dat", mesh)
def make_mesh(self, A=1):
self.getpoints()
# build the triangles
info = triangle.MeshInfo()
info.set_points(self.points)
info.set_holes([self.l.loc]) #the lumen is clear, it's a "hole"
info.set_facets(self.facets, facet_markers=self.markers)
info.regions.resize(len(self.parts))
j = 1
wall_out_avg_x = (np.min(np.array(self.a.draw_inner())[:, 0]) + np.min(
np.array(self.a.draw_outer())[:, 0])) / float(2)
wall_in_avg_x = (np.min(np.array(self.a.draw_inner())[:, 0]) +
np.min(np.array(self.l.draw())[:, 0])) / float(2)
avgs = [wall_out_avg_x, wall_in_avg_x]
for part in self.parts:
if j > 2:
info.regions[j - 1] = [part.loc[0], part.loc[1], j, A]
j = j + 1
else:
info.regions[j - 1] = [avgs[j - 1], 0, j, A]
j = j + 1
self.mesh_ = triangle.build(info,
refinement_func=refinement_func,
attributes=True)
return self.mesh_
def generate_mesh(self, mesh_size=5):
"""Setup Mesh Object and Properties
Go through generation Builder -> MeshInfo -> Mesh"""
# TODO Look into section-properties on github?
# TODO Are the values from meshpy.triangle accurate?
mesh_info = MeshInfo()
self.builder.set(mesh_info)
self.mesh = build(mesh_info, max_volume=mesh_size)
# Calculate Element Centroids
# C = [(x1+x2+x3)/3 , (y1+y2+y3)/3]
for i, e in enumerate(self.mesh.elements):
p1 = self.mesh.points[e[0]]
p2 = self.mesh.points[e[1]]
p3 = self.mesh.points[e[2]]
self.mesh_centroids[i] = ((p1[0] + p2[0] + p3[0]) / 3,
(p1[1] + p2[1] + p3[1]) / 3)
# Calculate Element Areas
# A = abs(x1*y2 + x2*y3 + x3*y1 - y1*x2 - y2*x3 - y3*x1)/2
for i, e in enumerate(self.mesh.elements):
p1 = self.mesh.points[e[0]]
p2 = self.mesh.points[e[1]]
p3 = self.mesh.points[e[2]]
self.mesh_areas[i] = abs(p1[0] * p2[1] + p2[0] * p3[1] +
p3[0] * p1[1] - p1[1] * p2[0] -
p2[1] * p3[0] - p3[1] * p1[0]) / 2
# Assign material ids to elements
# A bit verbose just to show calculations - might change later
# this only accounts for circle assignments
for primitive in self.ele_mat_primitive:
r = primitive[0]
prim_c = primitive[1]
mat_id = primitive[2]
for n, c in self.mesh_centroids.items():
if hypot(c[0] - prim_c[0], c[1] - prim_c[1]) < r:
self.ele_mat[n] = mat_id
def circle(r,h0,n):
# define the vertices on the circle
points = []
for i in range(n):
x = r*np.cos(i*2*np.pi/n)
y = r*np.sin(i*2*np.pi/n)
points.append([x,y])
# define the four edges between the four vertices of the square
facets = round_trip_connect(0, len(points)-1)
# initialize the mesh and set the vertices and the edges of the domain
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(facets)
# define a function that returns a boolean that is true if the triangle with
# vertices vtx and area a has maximal edge length larger than the desired
# maximal mesh width h0.
def needs_refinement(vtx, a):
return bool(max_edge_length(vtx) > h0)
# create the mesh giving the mesh information info and the refinement
# function needs_refinement as input
mesh = triangle.build(info, refinement_func=needs_refinement)
#mesh = triangle.build(info)
# read vertices and triangles of the mesh and convert the arrays to numpy
# arrays
p = np.array(mesh.points)
t = np.array(mesh.elements)
# return the vertices and triangles of the mesh
return (p, t)
def create_mesh(WSP_points, max_volume=10000, min_angle=25):
outer_polygon, *inner_polygons = simplify(WSP_points)
inner_points_of_holes = [inner_point(pol) for pol in inner_polygons]
points = outer_polygon
last_point_number = len(outer_polygon) - 1
facets = round_trip_connect(0, last_point_number)
for pol in inner_polygons:
points.extend(pol)
facets.extend(
round_trip_connect(last_point_number + 1,
last_point_number + len(pol)))
last_point_number = last_point_number + len(pol)
info = triangle.MeshInfo()
info.set_points(points)
info.set_holes(inner_points_of_holes)
info.set_facets(facets)
mesh = triangle.build(info, max_volume=max_volume, min_angle=min_angle)
mesh_points = np.array(mesh.points)
mesh_tris = np.array(mesh.elements)
mesh_facets = np.array(mesh.facets)
return mesh_points, mesh_tris
def par_mesh(h, n):
mesh_info = MeshInfo()
# Set the vertices of the domain [0, 1]^2
mesh_info.set_points([
(0,0), (1,0), (1,1), (0,1)])
# Set the facets of the domain [0, 1]^2
mesh_info.set_facets([
[0,1],
[1,2],
[2,3],
[3,0]
])
# Generate the tet mesh
mesh = build(mesh_info, max_volume=(h)**2)
node = np.array(mesh.points, dtype=np.float)
cell = np.array(mesh.elements, dtype=np.int)
tmesh = TriangleMesh(node, cell)
# Partition the mesh cells into n parts
if n > 1:
edgecuts, parts = metis.part_mesh(tmesh, nparts=n, entity='node')
else:
NN = tmesh.number_of_nodes()
parts = np.zeros(NN, dtype=np.int)
tmesh.nodedata['partition'] = parts
return tmesh
def main():
import meshpy.triangle as triangle
import math
import pickle
segments = 50
points = [(-5,-1), (-1,-1), (0,-1), (0,0), (1,0), (5,0), (5,1), (1,1),
(-1,1), (-5,1)]
def round_trip_connect(seq):
result = []
for i in range(len(seq)):
result.append((seq[i], seq[(i+1)%len(seq)]))
return result
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(
round_trip_connect([0,1,8,9])
+round_trip_connect([1,2,3,4,7,8])
+round_trip_connect([4,5,6,7])
)
info.regions.resize(3)
info.regions[0] = (-2,0, 1,0.1)
info.regions[1] = (-0.5,0, 0,0.01)
info.regions[2] = (1.5,0.5, 1,0.1)
mesh = triangle.build(info)
triangle.write_gnuplot_mesh("triangles.dat", mesh)
mesh.write_neu(open("tri_pml.neu", "w"))
def main():
import meshpy.triangle as triangle
import math
points = [ (1,1),(-1,1),(-1,-1),(1,-1) ]
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i+1))
result.append((end, start))
return result
def needs_refinement(vertices, area ):
vert_origin, vert_destination, vert_apex = vertices
bary_x = (vert_origin.x + vert_destination.x + vert_apex.x) / 3
bary_y = (vert_origin.y + vert_destination.y + vert_apex.y) / 3
dist_center = math.sqrt( (bary_x-1)**2 + (bary_y-1)**2 )
max_area = math.fabs( 0.05 * (dist_center-0.5) ) + 0.01
return area > max_area
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(round_trip_connect(0, len(points)-1))
mesh = triangle.build(info, refinement_func=needs_refinement)
mesh.write_neu(open("nico.neu", "w"))
triangle.write_gnuplot_mesh("triangles.dat", mesh)
def main():
import meshpy.triangle as triangle
info = triangle.MeshInfo()
info.set_points([ (1.5,1),(-1.2,1),(-1,-1),(1,-1)])
info.set_facets([(0, 1), (1, 2), (2, 3), (3, 0)])
mesh = triangle.build(info, max_volume=1e-3, min_angle=25)
print("""
<?xml version="1.0" encoding="UTF-8"?>
<dolfin xmlns:dolfin="http://www.fenics.org/dolfin/">
<mesh celltype="triangle" dim="2">
<vertices size="%d">
""" % len(mesh.points))
for i, pt in enumerate(mesh.points):
print('<vertex index="%d" x="%g" y="%g"/>' % (
i, pt[0], pt[1]))
print("""
</vertices>
<cells size="%d">
""" % len(mesh.elements))
for i, element in enumerate(mesh.elements):
print('<triangle index="%d" v0="%d" v1="%d" v2="%d"/>' % (
i, element[0], element[1], element[2]))
print("""
</cells>
</mesh>
</dolfin>
""")
def method(Lx=1.,
Ly=1.,
scale=0.75,
dx=0.02,
show=False,
polygon="flipper",
center=(0.5, 0.5),
**kwargs):
edges = np.loadtxt(os.path.join(MESHES_DIR, polygon + ".edges"),
dtype=int).tolist()
nodes = np.loadtxt(os.path.join(MESHES_DIR, polygon + ".nodes"))
nodes[:, 0] -= 0.5 * np.max(nodes[:, 0])
nodes[:, 1] -= 0.5 * np.max(nodes[:, 1])
nodes[:, :] *= scale
nodes[:, 0] += center[0] * Lx
nodes[:, 1] += center[1] * Ly
nodes = nodes.tolist()
x_min, x_max = 0., Lx
y_min, y_max = 0., Ly
corner_pts = [(x_min, y_min), (x_max, y_min), (x_max, y_max),
(x_min, y_max)]
outer_nodes, outer_edges = make_polygon(corner_pts, dx, len(nodes))
nodes.extend(outer_nodes)
edges.extend(outer_edges)
if show:
plot_edges(nodes, edges)
mi = tri.MeshInfo()
mi.set_points(nodes)
mi.set_facets(edges)
mi.set_holes([(center[0] * Lx, center[1] * Ly)])
max_area = 0.5 * dx**2
mesh = tri.build(mi,
max_volume=max_area,
min_angle=25,
allow_boundary_steiner=False)
coords = np.array(mesh.points)
faces = np.array(mesh.elements)
if show:
plot_faces(coords, faces)
mesh = numpy_to_dolfin(coords, faces)
if show:
df.plot(mesh)
plt.show()
mesh_path = os.path.join(MESHES_DIR,
"{}_dx{}_Lx{}_Ly{}".format(polygon, dx, Lx, Ly))
store_mesh_HDF5(mesh, mesh_path)
def make_disk_mesh(r=0.5, faces=50, max_area=4e-3,
boundary_tagger=(lambda fvi, el, fn, all_v: [])):
from math import cos, sin, pi
def needs_refinement(vertices, area):
return area > max_area
points = [(r*cos(angle), r*sin(angle))
for angle in numpy.linspace(0, 2*pi, faces, endpoint=False)]
import meshpy.triangle as triangle
mesh_info = triangle.MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets(
list(_round_trip_connect(0, faces-1)),
faces*[1]
)
generated_mesh = triangle.build(mesh_info, refinement_func=needs_refinement)
from hedge.mesh import make_conformal_mesh_ext
from hedge.mesh.element import Triangle
vertices = numpy.asarray(generated_mesh.points, dtype=float, order="C")
return make_conformal_mesh_ext(
vertices,
[Triangle(i, el_idx, vertices)
for i, el_idx in enumerate(generated_mesh.elements)],
boundary_tagger)
def test_tri_refinefunc(rfunc=None):
from meshpy import triangle
L = np.array([2., 2.])
points = np.array([
[0., 0.], [L[0], 0.], [L[0], L[1]], [0., L[1]]
])
edges = np.array([
[0, 1], [1, 2], [2, 3], [3, 0]
])
mesh_data = triangle.MeshInfo()
mesh_data.set_points(points)
mesh_data.set_facets(edges.tolist())
max_volume = 0.2**2
min_angle = 20.
mesh = triangle.build(
mesh_data,
max_volume=max_volume,
min_angle=min_angle,
refinement_func=rfunc
)
# Extract triangle vertices from triangulation adding back x coord
points = np.column_stack((
np.zeros(len(mesh.points)), np.array(mesh.points))
)
tris = np.array(mesh.elements, dtype=np.int32)
holes = np.empty((0,3), dtype=np.float64)
return points, tris, holes
def fractal_1_square_rough_mesh(b, dx):
if b == 0.0:
pts_low = [(0.0, 0.0), (0.1, 0.0)]
else:
pts_low = [(0.0, -b / 6), (b / 6, -b / 6), (b / 6, -b / 2),
(b / 2, -b / 2), (b / 2, b / 2), (5 * b / 6, b / 2),
(5 * b / 6, b / 6), (7 * b / 6, b / 6), (7 * b / 6, b / 2),
(3 * b / 2, b / 2), (3 * b / 2, -b / 2),
(11 * b / 6, -b / 2), (11 * b / 6, -b / 6), (2 * b, -b / 6)]
nodes = dict()
edges = []
pts = []
for pt_low in pts_low:
pts.append((pt_low[0], pt_low[1] - 1))
for pt_low in pts_low[::-1]:
pts.append((pt_low[0], -pt_low[1] + 1))
pts.append(pts[0])
for pta, ptb in zip(pts[:-1], pts[1:]):
ra = np.array(pta)
rb = np.array(ptb)
dr = ra - rb
drabs = np.sqrt(sum(dr**2))
Nseg = int(np.ceil(drabs / dx))
beta = np.linspace(0., 1., Nseg)
rs = [tuple(betai * rb + (1 - betai) * ra) for betai in beta]
for r in rs:
if r not in nodes:
nodes[r] = len(nodes)
for ri, rj in zip(rs[:-1], rs[1:]):
edge = [nodes[ri], nodes[rj]]
edges.append(edge)
nodes = dict2list(nodes)
mi = tri.MeshInfo()
mi.set_points(nodes)
mi.set_facets(edges)
max_area = 0.5 * dx**2
mesh = tri.build(mi,
max_volume=max_area,
min_angle=25,
allow_boundary_steiner=False)
coords = np.array(mesh.points)
faces = np.array(mesh.elements)
msh = numpy_to_dolfin(coords, faces)
return msh
def create_quality_mesh(num_unknowns):
mesh_info = triangle.MeshInfo()
points = [(1.5, 1.5), (-1.5, 1.5), (-1.5, -1.5), (1.5, -1.5)]
segments = [(i, i + 1) for i in range(3)] + [(3, 0)]
mesh_info.set_points(points)
mesh_info.set_facets(segments)
mesh = triangle.build(mesh_info,
max_volume=3 / (num_unknowns * 2**2),
min_angle=30)
return mesh
def make_poly_mesh(points, facets, facet_markers, refinement_func=None):
import meshpy.triangle as triangle
mesh_info = triangle.MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets(facets, facet_markers)
mesh_info.holes.resize(1)
mesh_info.holes[0] = [0,0]
return triangle.build(mesh_info,
refinement_func=refinement_func,
generate_edges=True)
def triangle(box, h):
from meshpy.triangle import MeshInfo, build
mesh_info = MeshInfo()
mesh_info.set_points([(box[0], box[2]), (box[1], box[2]), (box[1], box[3]),
(box[0], box[3])])
mesh_info.set_facets([[0, 1], [1, 2], [2, 3], [3, 0]])
mesh = build(mesh_info, max_volume=h**2)
point = np.array(mesh.points, dtype=np.float)
cell = np.array(mesh.elements, dtype=np.int)
return TriangleMesh(point, cell)
def make_poly_mesh(points, facets, facet_markers, refinement_func=None):
import meshpy.triangle as triangle
mesh_info = triangle.MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets(facets, facet_markers)
mesh_info.holes.resize(1)
mesh_info.holes[0] = [0, 0]
return triangle.build(mesh_info,
refinement_func=refinement_func,
generate_edges=True)
def circle(r,h0,n):
n = max(n,int(np.ceil(2.0*np.pi*r/h0)))
points = [(r*np.cos(2*np.pi*i/float(n)), r*np.sin(2*np.pi*i/float(n))) for i in range(0, n)]
facets = round_trip_connect(0, len(points)-1)
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(facets)
def needs_refinement(vertices, area):
return bool(max_edge_length(vertices) > h0)
mesh = triangle.build(info, refinement_func=needs_refinement)
return (np.array(mesh.points), np.array(mesh.elements))
def make_rect_mesh_with_corner(a=(0, 0), b=(1, 1), max_area=None,
boundary_tagger=(lambda fvi, el, fn, all_v: []),
corner_fraction=(0.3, 0.3),
refine_func=None):
"""Create an unstructured rectangular mesh with a reentrant
corner at (-x, -y).
:param a: the lower left hand point of the rectangle
:param b: the upper right hand point of the rectangle
:param max_area: maximum area of each triangle.
:param refine_func: A refinement function as taken by
:func:`meshpy.triangle.build`.
:param corner_fraction: Tuple of fraction of the width taken up by
the rentrant corner.
"""
if max_area is not None:
if refine_func is not None:
raise ValueError("cannot specify both refine_func and max_area")
def refine_func(vertices, area):
return area > max_area
a = numpy.asarray(a)
b = numpy.asarray(b)
diag = b-a
w = diag.copy()
w[1] = 0
h = diag.copy()
h[0] = 0
points = [
a+h*corner_fraction[1],
a+h*corner_fraction[1]+w*corner_fraction[0],
a+w*corner_fraction[0],
a+w,
a+w+h,
a+h,
]
facets = list(_round_trip_connect(0, 5))
facet_markers = [5, 6, 2, 3, 4, 1]
import meshpy.triangle as triangle
mesh_info = triangle.MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets(facets, facet_markers)
generated_mesh = triangle.build(mesh_info,
refinement_func=refine_func)
from hedge.mesh import make_conformal_mesh
return make_conformal_mesh(
generated_mesh.points,
generated_mesh.elements,
boundary_tagger)
def DoTriMesh(points, vertices, edge_length=-1, holes=[], tri_refine=None):
info = triangle.MeshInfo()
info.set_points(points)
if len(holes) > 0:
info.set_holes(holes)
info.set_facets(vertices)
if tri_refine != None:
mesh = triangle.build(info, refinement_func=tri_refine)
elif edge_length <= 0:
mesh = triangle.build(info)
else:
mesh = triangle.build(info, max_volume=0.5 * edge_length**2)
mesh_points = np.array(mesh.points)
mesh_elements = np.array(mesh.elements)
#plt.triplot(mesh_points[:, 0], mesh_points[:, 1], mesh_elements,)
#plt.show()
return mesh_points, mesh_elements
def init_mesh(self, meshtype='tri', h=0.1):
""" generate the initial mesh
"""
from meshpy.triangle import build
domain = self.domain()
mesh = build(domain, max_volume=h**2)
node = np.array(mesh.points, dtype=np.float)
cell = np.array(mesh.elements, dtype=np.int)
if meshtype is 'tri':
mesh = TriangleMesh(node, cell)
return mesh
def triangulate_PSLGs(pslgs, area_constraints):
"""Triangulates lower boundaries along each coordinate axis using Shewchuk's
Triangle library.
:param pslgs list: list of PSLG objects for the boundaries.
:param area_constraints AreaConstraints: object storing area constraint grids for
quality triangulation.
:return: list of BoundaryPLC objects for the triangulated boundaries.
:rtype: list.
"""
triangulated_boundaries = []
for i, pslg in enumerate(pslgs):
target_area_grid = area_constraints.grid[i]
inv_dx = area_constraints.inv_dx[i]
inv_dy = area_constraints.inv_dy[i]
def rfunc(vertices, area):
(ox, oy), (dx, dy), (ax, ay) = vertices
cx = ONE_THIRD * (ox + dx + ax) # Triangle center x coord.
cy = ONE_THIRD * (oy + dy + ay) # Triangle center y coord.
ix = int(cx * inv_dx)
iy = int(cy * inv_dy)
target_area = target_area_grid[iy][ix]
return int(area > target_area) # True -> 1 means refine
# Set mesh info for triangulation
mesh_data = triangle.MeshInfo()
mesh_data.set_points(pslg.points)
mesh_data.set_facets(pslg.edges.tolist())
if len(pslg.holes):
mesh_data.set_holes(pslg.holes)
# Call triangle library to perform Delaunay triangulation
max_volume = area_constraints.dA_max
min_angle = 20.
mesh = triangle.build(mesh_data,
max_volume=max_volume,
min_angle=min_angle,
allow_boundary_steiner=False,
refinement_func=rfunc)
# Extract triangle vertices from triangulation adding back x coord
points = np.column_stack(
(np.zeros(len(mesh.points)), np.array(mesh.points)))
points = points[:, (-i % 3, (1 - i) % 3, (2 - i) % 3)]
tris = np.array(mesh.elements)
holes = np.column_stack(
(np.zeros(len(mesh.holes)), np.array(mesh.holes)))
holes = holes[:, (-i % 3, (1 - i) % 3, (2 - i) % 3)]
triangulated_boundaries.append(BoundaryPLC(points, tris, holes))
return triangulated_boundaries
def main():
import meshpy.triangle as triangle
import math
import pickle
segments = 50
points = [(1, 0), (1, 1), (-1, 1), (-1, -1), (1, -1), (1, 0)]
for i in range(0, segments + 1):
angle = i * 2 * math.pi / segments
points.append((0.5 * math.cos(angle), 0.5 * math.sin(angle)))
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i + 1))
result.append((end, start))
return result
def needs_refinement(vertices, area):
vert_origin, vert_destination, vert_apex = vertices
bary_x = (vert_origin.x + vert_destination.x + vert_apex.x) / 3
bary_y = (vert_origin.y + vert_destination.y + vert_apex.y) / 3
dist_center = math.sqrt(bary_x**2 + bary_y**2)
max_area = 100 * (math.fabs(0.002 * (dist_center - 0.5)) + 0.0001)
return area > max_area
info = triangle.MeshInfo()
info.set_points(points)
info.set_holes([(0, 0)])
info.set_facets(round_trip_connect(0, len(points) - 1))
mesh = triangle.build(
info,
refinement_func=needs_refinement,
)
triangle.write_gnuplot_mesh("triangles-unrefined.dat", mesh)
print len(mesh.elements)
mesh.element_volumes.setup()
for i in range(len(mesh.elements)):
mesh.element_volumes[i] = -1
for i in range(0, len(mesh.elements), 10):
mesh.element_volumes[i] = 1e-8
mesh = triangle.refine(mesh)
print len(mesh.elements)
triangle.write_gnuplot_mesh("triangles.dat", mesh)
def main():
import meshpy.triangle as triangle
points = [(0,0), (1,0), (1,1), (0,1)]
left_points = [(0.2, 0.25), (0.4, 0.25), (0.4, 0.5), (0.2, 0.5)]
right_points = [(0.8, 0.25), (0.6, 0.25), (0.6, 0.5), (0.8, 0.5)]
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i+1))
result.append((end, start))
return result
info = triangle.MeshInfo()
info.set_points(points + left_points + right_points)
outer_facets = round_trip_connect(0, len(points)-1)
left_facets = round_trip_connect(len(points), len(points) + len(left_points) - 1)
right_facets = round_trip_connect(len(points) + len(left_points), len(points) + len(left_points) + len(right_points) - 1)
info.set_facets(outer_facets + left_facets + right_facets)
info.set_holes([(0.3, 0.3)] + [(0.7, 0.3)])
mesh = triangle.build(info, max_volume=1e-3, min_angle=25)
f = open('output.xml', 'w')
f.write("""
<?xml version="1.0" encoding="UTF-8"?>
<dolfin xmlns:dolfin="http://www.fenics.org/dolfin/">
<mesh celltype="triangle" dim="2">
<vertices size="%d">
""" % len(mesh.points))
for i, pt in enumerate(mesh.points):
f.write('<vertex index="%d" x="%g" y="%g"/>' % (
i, pt[0], pt[1]))
f.write("""
</vertices>
<cells size="%d">
""" % len(mesh.elements))
for i, element in enumerate(mesh.elements):
f.write('<triangle index="%d" v0="%d" v1="%d" v2="%d"/>' % (
i, element[0], element[1], element[2]))
f.write("""
</cells>
</mesh>
</dolfin>
""")
def DoTriMesh(points,vertices,edge_length=-1,holes=[],tri_refine=None):
info = triangle.MeshInfo()
info.set_points(points)
if len(holes)>0:
info.set_holes(holes)
info.set_facets(vertices)
if tri_refine!=None:
mesh = triangle.build(info,refinement_func=tri_refine)
elif edge_length<=0:
mesh = triangle.build(info)
else:
mesh = triangle.build(info,max_volume=0.5*edge_length**2)
mesh_points = np.array(mesh.points)
mesh_elements = np.array(mesh.elements)
plt.triplot(mesh_points[:, 0], mesh_points[:, 1], mesh_elements,)
plt.show()
return mesh_points,mesh_elements;
def create_mesh(points,
facets,
holes,
control_points,
mesh_sizes,
atol=1.0e-8):
"""Creates a quadratic triangular mesh using the meshpy 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 atol: minimum permissable point distance from any section facet
:type atol: float
:return: Object containing generated mesh data
:rtype: :class:`meshpy.triangle.MeshInfo`
"""
check_geometry(points, facets, holes, control_points, atol=atol)
mesh = triangle.MeshInfo() # create mesh info object
mesh.set_points(points) # set points
mesh.set_facets(facets) # set facets
mesh.set_holes(holes) # set holes
# set regions
mesh.regions.resize(len(control_points)) # resize regions list
region_id = 0 # initialise region ID variable
for (i, cp) in enumerate(control_points):
mesh.regions[i] = [cp[0], cp[1], region_id, mesh_sizes[i]]
region_id += 1
mesh = triangle.build(mesh,
min_angle=30,
mesh_order=2,
quality_meshing=True,
attributes=True,
volume_constraints=True)
return mesh
def make_mesh(max_volume):
def round_trip_connect(seq):
result = []
for i in range(len(seq)):
result.append((i, (i+1)%len(seq)))
return result
shapes = read_shape()
#from matplotlib.pyplot import plot,show
#plot(shapes[0][:,0], shapes[0][:,1])
#show()
from meshpy.geometry import GeometryBuilder, Marker
builder = GeometryBuilder()
for shape in shapes:
from meshpy.geometry import make_box
points = shape
facets = round_trip_connect(range(len(points)))
builder.add_geometry(points=points, facets=facets,
facet_markers=Marker.FIRST_USER_MARKER)
points, facets, facet_markers = make_box((-200, -600), (400, -300))
builder.add_geometry(points=points, facets=facets,
facet_markers=facet_markers)
def transform(pt):
x, y = pt
return -0.01*x, -0.01*y
builder.apply_transform(transform)
from meshpy.triangle import MeshInfo, build
mi = MeshInfo()
builder.set(mi)
holes = []
for shape, sign, frac in zip(shapes, [1, 1, -1, 1, 1, 1], [0.5, 0, 0, 0, 0, 0]):
avg = np.average(shape, axis=0)
start_idx = int(frac*shape.shape[0])
start = shape[start_idx]
holes.append(transform(start + sign*0.01*(avg-start)))
mi.set_holes(holes)
mesh = build(mi,
allow_boundary_steiner=True,
generate_faces=True,
max_volume=max_volume)
return mesh
def main():
import meshpy.triangle as triangle
import math
import pickle
segments = 50
points = [ (1,0),(1,1),(-1,1),(-1,-1),(1,-1),(1,0) ]
for i in range( 0, segments + 1 ):
angle = i * 2 * math.pi / segments
points.append( ( 0.5 * math.cos( angle ), 0.5 * math.sin( angle ) ) )
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i+1))
result.append((end, start))
return result
def needs_refinement(vertices, area ):
vert_origin, vert_destination, vert_apex = vertices
bary_x = (vert_origin.x + vert_destination.x + vert_apex.x) / 3
bary_y = (vert_origin.y + vert_destination.y + vert_apex.y) / 3
dist_center = math.sqrt( bary_x**2 + bary_y**2 )
max_area = 100*(math.fabs( 0.002 * (dist_center-0.5) ) + 0.0001)
return area > max_area
info = triangle.MeshInfo()
info.set_points(points)
info.set_holes([(0,0)])
info.set_facets(round_trip_connect(0, len(points)-1))
mesh = triangle.build(info, refinement_func=needs_refinement,
)
triangle.write_gnuplot_mesh("triangles-unrefined.dat", mesh)
print(len(mesh.elements))
mesh.element_volumes.setup()
for i in range(len(mesh.elements)):
mesh.element_volumes[i] = -1
for i in range(0, len(mesh.elements), 10):
mesh.element_volumes[i] = 1e-8
mesh = triangle.refine(mesh)
print(len(mesh.elements))
triangle.write_gnuplot_mesh("triangles.dat", mesh)
def triangulate_rings(rings, holes=None):
return (
np.zeros((0, 2), dtype=np.uint32),
np.zeros((0, 3), dtype=np.uint32),
)
rings = tuple(
tuple(
tuple(vertex) for vertex in np.rint(np.array(ring.coords) *
1000).astype(np.int32))
for ring in rings)
if not rings:
return np.empty((0, 2), dtype=np.int32), np.empty((0, 3),
dtype=np.uint32)
vertices = tuple(set(chain(*rings)))
vertices_lookup = {vertex: i for i, vertex in enumerate(vertices)}
segments = set()
for ring in rings:
indices = tuple(vertices_lookup[vertex] for vertex in ring[:-1])
segments.update(
tuple(sorted((a, b)))
for a, b in zip(indices, indices[1:] + indices[:1]) if a != b)
if len(segments) < 3:
return np.empty((0, 2), dtype=np.int32), np.empty((0, 3),
dtype=np.uint32)
# noinspection PyArgumentList
info = triangle.MeshInfo()
info.set_points(np.array(vertices).tolist())
info.set_facets(segments)
if holes is not None:
info.set_holes(np.rint(np.array(holes) * 1000))
mesh = triangle.build(info, quality_meshing=False)
mesh_points = np.rint(np.array(mesh.points)).astype(np.int32)
mesh_elements = np.array(mesh.elements, dtype=np.uint32)
# remove triangles with no area
facets = np.dstack(
(np.zeros(mesh_elements.shape), mesh_points[mesh_elements]))
ok_index = np.cross(facets[:, 1] - facets[:, 0],
facets[:, 2] - facets[:, 1]).max(axis=1) != 0
mesh_elements = mesh_elements[ok_index]
return mesh_points, mesh_elements
def triangle_polygon_domain(points, facets, h, meshtype='tri'):
from meshpy.triangle import MeshInfo, build
mesh_info = MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets(facets)
mesh = build(mesh_info, max_volume=h**2)
node = np.array(mesh.points, dtype=np.float)
cell = np.array(mesh.elements, dtype=np.int)
if meshtype is 'tri':
return TriangleMesh(node, cell)
elif meshtype is 'polygon':
mesh = TriangleMeshWithInfinityNode(TriangleMesh(node, cell))
pnode, pcell, pcellLocation = mesh.to_polygonmesh()
return PolygonMesh(pnode, pcell, pcellLocation)
def finish_2d_rect_mesh(points, facets, facet_markers, marker2tag, refine_func,
periodicity, boundary_tagger):
"""Semi-internal bottom-half routine for generation of rectangular 2D meshes."""
import meshpy.triangle as triangle
mesh_info = triangle.MeshInfo()
mesh_info.set_points(points)
mesh_info.set_facets(facets, facet_markers)
#triangle.write_gnuplot_mesh("mesh.dat", mesh_info, True)
if periodicity is None:
periodicity = (False, False)
axes = ["x", "y"]
mesh_periodicity = []
periodic_tags = set()
for i, axis in enumerate(axes):
if periodicity[i]:
minus_tag = "minus_"+axis
plus_tag = "plus_"+axis
mesh_periodicity.append((minus_tag, plus_tag))
periodic_tags.add(minus_tag)
periodic_tags.add(plus_tag)
else:
mesh_periodicity.append(None)
generated_mesh = triangle.build(mesh_info,
refinement_func=refine_func,
allow_boundary_steiner=not (periodicity[0] or periodicity[1]))
fmlookup = MeshPyFaceMarkerLookup(generated_mesh)
def wrapped_boundary_tagger(fvi, el, fn, all_v):
btag = marker2tag[fmlookup(fvi)]
if btag in periodic_tags:
return [btag]
else:
return [btag] + boundary_tagger(fvi, el, fn, all_v)
vertices = numpy.asarray(generated_mesh.points, dtype=float, order="C")
from hedge.mesh import make_conformal_mesh_ext
from hedge.mesh.element import Triangle
return make_conformal_mesh_ext(
vertices,
[Triangle(i, el_idx, vertices)
for i, el_idx in enumerate(generated_mesh.elements)],
wrapped_boundary_tagger,
periodicity=mesh_periodicity)
def main():
import meshpy.triangle as triangle
import math
segments = 10
points = [ (1,0),(1,1),(-1,1),(-1,-1),(1,-1),(1,0) ]
for i in range( 0, segments + 1 ):
angle = i * 2 * math.pi / segments
points.append( ( 0.5 * math.cos( angle ), 0.5 * math.sin( angle ) ) )
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i+1))
result.append((end, start))
return result
def needs_refinement(vertices, area ):
vert_origin, vert_destination, vert_apex = vertices
bary_x = (vert_origin.x + vert_destination.x + vert_apex.x) / 3
bary_y = (vert_origin.y + vert_destination.y + vert_apex.y) / 3
dist_center = math.sqrt( bary_x**2 + bary_y**2 )
max_area = math.fabs( 0.002 * (dist_center-0.5) ) + 0.0001
return area > max_area
info = triangle.MeshInfo()
info.set_points(points)
info.set_holes([(0,0)])
info.set_facets(round_trip_connect(0, len(points)-1))
mesh = triangle.build(info, refinement_func=needs_refinement)
import numpy as np
#np.set_printoptions(threshold=100000)
print repr(np.array(mesh.points))
print repr(np.array(mesh.elements))
#import pickle
#pickled = pickle.dumps(mesh)
#mesh_2 = pickle.loads(pickled)
triangle.write_gnuplot_mesh("triangles.dat", mesh)
def build(self):
if self.h:
V0 = (self.h**2)/2.0
else:
hauto = min(self.geom.width/10.0, self.geom.height/10.0)
V0 = (hauto**2)/2.0
info = triangle.MeshInfo()
info.set_points(self.geom.points)
info.set_facets(self.geom.facets)
mesh = triangle.build(info, max_volume=V0)
self.nodes = np.array(mesh.points)
self.elmCon = np.array(mesh.elements).astype("int32")
self.boundary = np.array(mesh.facets).astype("int32")
self.nNodes = self.nodes.shape[0]
self.nElm = self.elmCon.shape[0]
self.nBoundary = self.boundary.shape[0]
self.compute_quadpoints()
print self.nodes.shape, self.elmCon.shape, self.boundary.shape
def make_mesh():
outline = np.loadtxt(sys.argv[1])
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i+1))
result.append((end, start))
return result
info = triangle.MeshInfo()
info.set_points(outline)
info.set_facets(round_trip_connect(0, len(outline)-1))
return triangle.build(info,
refinement_func=getattr(Refiners, "needs_refinement_%s" % sys.argv[2]))
def main():
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i+1))
result.append((end, start))
return result
corners, mesh1, mesh2 = generate_meshes(2, 1, 0.3)
points = get_vertices(corners, mesh1, mesh2)
print "points", np.array(points)
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(round_trip_connect(0, len(corners)-1))
mesh = triangle.build(info, allow_volume_steiner=False, allow_boundary_steiner=False, min_angle=60)
if False:
print "vertices:"
for i, p in enumerate(mesh.points):
print i, p
print "point numbers in triangles:"
for i, t in enumerate(mesh.elements):
print i, t
finemesh = Mesh()
ME = MeshEditor()
ME.open(finemesh,2,2)
ME.init_vertices(len(mesh.points))
ME.init_cells(len(mesh.elements))
for i,v in enumerate(mesh.points):
ME.add_vertex(i,v[0],v[1])
for i,c in enumerate(mesh.elements):
ME.add_cell(i,c[0],c[1],c[2])
ME.close()
triangle.write_gnuplot_mesh("triangles.dat", mesh)
plot(mesh1)
plot(mesh2)
plot(finemesh)
interactive()
def main():
points = [(1, 0), (1, 1), (-1, 1), (-1, -1), (1, -1), (1, 0)]
facets = round_trip_connect(0, len(points)-1)
markers = [2,2,2,2,2,2]
outter_start = len(points)
points.extend([(2, 0), (2, 2), (-2, 2), (-2, -2), (2, -2), (2, 0)])
facets.extend(round_trip_connect(outter_start, len(points) - 1))
markers.extend([3,3,3,3,3,3])
# build
info = triangle.MeshInfo()
info.set_points(points)
info.set_holes([(0, 0)])
info.set_facets(facets, facet_markers=markers)
#
mesh = triangle.build(info, refinement_func=refinement_func)
#
mesh_points = np.array(mesh.points)
mesh_tris = np.array(mesh.elements)
mesh_attr = np.array(mesh.point_markers)
print(mesh_attr)
import matplotlib.pyplot as plt
plt.triplot(mesh_points[:, 0], mesh_points[:, 1], mesh_tris)
plt.xlabel('x')
plt.ylabel('y')
#
n = np.size(mesh_attr);
inner_nodes = [i for i in range(n) if mesh_attr[i]==2]
outer_nodes = [i for i in range(n) if mesh_attr[i]==3]
plt.plot(mesh_points[inner_nodes, 0], mesh_points[inner_nodes, 1], 'ro')
plt.plot(mesh_points[outer_nodes, 0], mesh_points[outer_nodes, 1], 'go')
plt.axis([-2.5, 2.5, -2.5, 2.5])
#plt.show()
#
fig = plt.gcf()
fig.set_size_inches(4.2, 4.2)
plt.savefig('sec5-meshpy-triangle-ex5.pdf')
def main():
import meshpy.triangle as triangle
points = [ (1,1),(-1,1),(-1,-1),(1,-1)]
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i+1))
result.append((end, start))
return result
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(round_trip_connect(0, len(points)-1))
mesh = triangle.build(info, max_volume=1e-3, min_angle=25)
print "A"
triangle.write_gnuplot_mesh("triangles.dat", mesh)
def get_mesh_example(): area = rect((0.,0.),(1.,1.)) init = rect((0.1,0.1),(0.2,0.2)) goal1 = rect((0.8,0.8),(0.9,0.9)) goal2 = rect((0.2,0.8),(0.3,0.9)) env = area + goal1 + goal2 + init info = MeshInfo() info.set_points(env) info.set_facets(loop(0,4) + loop(4,8) + loop(8,12) + loop(12,16), facet_markers = [0]*4 + [1]*4 + [2]*4 + [3]*4) # Create 8 facets and apply markers 1-8 on them info.regions.resize(4) s = 0.05 info.regions[0] = [0.15, 0.15, 0, s] # Replace 0.1 by a smaller value to produce a finer mesh info.regions[1] = [0.25, 0.85, 1, s] # Fourth item specifies maximum area of triangles as a region attribute info.regions[2] = [0.85, 0.85, 2, s] # Replace 0.1 by a smaller value to produce a finer mesh info.regions[3] = [0.5, 0.5, 3, s] # Fourth item specifies maximum area of triangles as a region attribute mesh = build(info, volume_constraints=True, attributes=True, generate_faces=True, min_angle=20, mesh_order=1) return mesh
def main():
points = [(1, 0), (1, 1), (-1, 1), (-1, -1), (1, -1), (1, 0)]
facets = round_trip_connect(0, len(points)-1)
circ_start = len(points)
points.extend(
(3 * np.cos(angle), 3 * np.sin(angle))
for angle in np.linspace(0, 2*np.pi, 30, endpoint=False))
facets.extend(round_trip_connect(circ_start, len(points)-1))
markers = [2,2,2,2,2,2]
markers.extend(list(np.ones(30, dtype='int')))
markers = [int(i) for i in markers]
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(facets, facet_markers=markers)
#
info.regions.resize(1)
# points [x,y] in region, + region number, + regional area constraints
info.regions[0] = ([0,0] + [1,0.05])
mesh = triangle.build(info, volume_constraints=True, max_volume=0.1)
mesh_points = np.array(mesh.points)
mesh_tris = np.array(mesh.elements)
mesh_attr = np.array(mesh.point_markers)
print(mesh_attr)
import matplotlib.pyplot as plt
plt.triplot(mesh_points[:, 0], mesh_points[:, 1], mesh_tris)
plt.xlabel('x')
plt.ylabel('y')
#
fig = plt.gcf()
fig.set_size_inches(4.2, 4.2)
plt.savefig('sec5-meshpy-triangle-ex4.pdf')
def main():
import meshpy.triangle as triangle
import numpy as np
points = [ (1,1),(-1,1),(-1,-1),(1,-1) ]
for pt in np.random.randn(100, 2):
points.append(pt*0.1)
def round_trip_connect(start, end):
result = []
for i in range(start, end):
result.append((i, i+1))
result.append((end, start))
return result
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(round_trip_connect(0, 3))
mesh = triangle.build(info, allow_volume_steiner=False,
allow_boundary_steiner=False)
triangle.write_gnuplot_mesh("triangles.dat", mesh)
def triangulate_polygon(polygon, **kwargs):
'''
Given a shapely polygon, create a triangulation using meshpy.triangle
Arguments
---------
polygon: Shapely.geometry.Polygon
kwargs: passed directly to meshpy.triangle.build:
triangle.build(mesh_info,
verbose=False,
refinement_func=None,
attributes=False,
volume_constraints=True,
max_volume=None,
allow_boundary_steiner=True,
allow_volume_steiner=True,
quality_meshing=True,
generate_edges=None,
generate_faces=False,
min_angle=None)
Returns
--------
mesh_vertices: (n, 2) float array of 2D points
mesh_faces: (n, 3) int array of vertex indicies representing triangles
'''
import meshpy.triangle as triangle
def round_trip(start, length):
'''
Given a start index and length, create a series of (n, 2) edges which
create a closed traversal.
Example:
start, length = 0, 3
returns: [(0,1), (1,2), (2,0)]
'''
tiled = np.tile(np.arange(start, start+length).reshape((-1,1)), 2)
tiled = tiled.reshape(-1)[1:-1].reshape((-1,2))
tiled = np.vstack((tiled, [tiled[-1][-1], tiled[0][0]]))
return tiled
def add_boundary(boundary, start):
# coords is an (n, 2) ordered list of points on the polygon boundary
# the first and last points are the same, and there are no
# guarentees on points not being duplicated (which will
# later cause meshpy/triangle to shit a brick)
coords = np.array(boundary.coords)
# find indices points which occur only once, and sort them
# to maintain order
unique = np.sort(unique_rows(coords)[0])
cleaned = coords[unique]
vertices.append(cleaned)
facets.append(round_trip(start, len(cleaned)))
# holes require points inside the region of the hole, which we find
# by creating a polygon from the cleaned boundary region, and then
# using a representative point. You could do things like take the mean of
# the points, but this is more robust (to things like concavity), if slower.
test = Polygon(cleaned)
holes.append(np.array(test.representative_point().coords)[0])
return len(cleaned)
#sequence of (n,2) points in space
vertices = deque()
#sequence of (n,2) indices of vertices
facets = deque()
#list of (2) vertices in interior of hole regions
holes = deque()
start = add_boundary(polygon.exterior, 0)
for interior in polygon.interiors:
try: start += add_boundary(interior, start)
except:
log.warn('invalid interior, continuing')
continue
# create clean (n,2) float array of vertices
# and (m, 2) int array of facets
# by stacking the sequence of (p,2) arrays
vertices = np.vstack(vertices)
facets = np.vstack(facets)
# holes in meshpy lingo are a (h, 2) list of (x,y) points
# which are inside the region of the hole
# we added a hole for the exterior, which we slice away here
holes = np.array(holes)[1:]
# call meshpy.triangle on our cleaned representation of the Shapely polygon
info = triangle.MeshInfo()
info.set_points(vertices)
info.set_facets(facets)
info.set_holes(holes)
# uses kwargs
mesh = triangle.build(info, **kwargs)
mesh_vertices = np.array(mesh.points)
mesh_faces = np.array(mesh.elements)
return mesh_vertices, mesh_faces
w_min = min([wj for wi in w for wj in wi])
w_max = max([wj for wi in w for wj in wi])
plt.subplot(2, 1, 1)
plot = plt.contourf(x, y, w)
plt.colorbar(plot, orientation='vertical')
edges = np.array(range(len(points)))
edges = np.array([edges, edges + 1]).T
edges[-1, -1] = 0
info = triangle.MeshInfo()
info.set_points(points)
info.set_facets(edges)
mesh = triangle.build(info, max_volume=0.01)
mesh_points = list(mesh.points)
triangles = list(mesh.elements)
femCase = stVenant.TorsionFemCase(mesh_points, triangles)
femCase.run()
print("number of elements: ", len(triangles))
print("torsion-moment", femCase.get_torsion_moment())
print("polar-moment", femCase.get_polar_moment())
x, y = np.array(mesh_points).T
triang = mtri.Triangulation(x, y, triangles)
plt.subplot(2, 1, 2)
previous_step = step
"""
Triangulation:
- set the points we want to triangulate
- mark the holes we want to ignore by their interior points
- triangulation: no interior steiner points, we want triangles to fill
the whole space between two boundaries. Allowing for quality meshing
would also mess with the triangulation we want.
"""
info = triangle.MeshInfo() #Create triangulation object.
info.set_points(mesh_points) #Set points to be triangulated.
if(len(hole_points) > 0):
info.set_holes(hole_points) #Set holes (contours) to be ignored.
info.set_facets(mesh_facets) #Set facets.
triangulation = triangle.build(info,verbose=False,allow_boundary_steiner=False,#Build Triangulation.
allow_volume_steiner=False,quality_meshing=False)
if verbose:
step = time.clock() #progress output
print pa + "Done in %1.2f sec."%(step-previous_step)
print "\n" + pa + "Current step: Setup of triangles and neighborhood relations."
previous_step = step
"""
Triangle classification:
- build triangle-objects from the triangulation
- set the type of each triangle (junction, normal, end or isolated)
depending on how many neighbors it has
- set the radius of each triangle by looking up its "midpoint"
in the distance map
- get rid of isolated triangles
# Utility function to create lists of the form [(1,2), (2,3), (3,4), # (4,1)], given two numbers 1 and 4 from itertools import islice, cycle from six.moves import range from six.moves import zip loop = lambda a, b: list(zip(list(range(a, b)), islice(cycle(list(range(a, b))), 1, None))) info = MeshInfo() info.set_points([(0, 0), (1, 0), (1, 1), (0, 1), (2, 0), (3, 0), (3, 1), (2, 1)]) info.set_facets(loop(0, 4) + loop(4, 8), list(range(1, 9))) # Create 8 facets and apply markers 1-8 on them info.regions.resize(2) info.regions[0] = [0.5, 0.5, 1, 0.1] # Fourth item specifies maximum area of triangles as a region attribute info.regions[1] = [2.5, 0.5, 2, 0.1] # Replace 0.1 by a smaller value to produce a finer mesh mesh = build(info, volume_constraints=True, attributes=True, generate_faces=True, min_angle=33, mesh_order=2) pts = vstack(mesh.points) # (npoints, 2)-array of points elements = vstack(mesh.elements) # (ntriangles, 6)-array specifying element connectivity # Matplotlib's Triangulation module uses only linear elements, so use only first 3 columns when plotting triplot(pts[:, 0], pts[:, 1], elements[:, :3]) plot(pts[:, 0], pts[:, 1], "ko") # Manually plot all points including the ones at the midpoints of triangle faces # Plot a filled contour plot of the function (x - 1.5)^2 + y^2 over # the mesh. Note tricontourf interpolation uses only linear elements tricontourf(pts[:, 0], pts[:, 1], elements[:, :3], (pts[:, 0] - 1.5) ** 2 + pts[:, 1] ** 2, 100) axis([-0.1, 3.1, -0.8, 1.8]) show()
def triangulate_polygon(polygon,
triangle_args='pq30',
engine='auto',
**kwargs):
"""
Given a shapely polygon create a triangulation using one
of the python interfaces to triangle.c:
> pip install meshpy
> pip install triangle
Parameters
---------
polygon : Shapely.geometry.Polygon
Polygon object to be triangulated
triangle_args : str
Passed to triangle.triangulate
engine : str
'meshpy', 'triangle', or 'auto'
kwargs: passed directly to meshpy.triangle.build:
triangle.build(mesh_info,
verbose=False,
refinement_func=None,
attributes=False,
volume_constraints=True,
max_volume=None,
allow_boundary_steiner=True,
allow_volume_steiner=True,
quality_meshing=True,
generate_edges=None,
generate_faces=False,
min_angle=None)
Returns
--------------
vertices : (n, 2) float
Points in space
faces : (n, 3) int
Index of vertices that make up triangles
"""
# turn the polygon in to vertices, segments, and hole points
arg = _polygon_to_kwargs(polygon)
try:
if str(engine).strip() in ['auto', 'triangle']:
from triangle import triangulate
result = triangulate(arg, triangle_args)
return result['vertices'], result['triangles']
except ImportError:
# no `triangle` so move on to `meshpy`
pass
except BaseException as E:
# if we see an exception log it and move on
log.error('failed to triangulate using triangle!',
exc_info=True)
# if we are running unit tests exit here and fail
if tol.strict:
raise E
# do the import here, as sometimes this import can segfault
# which is not catchable with a try/except block
from meshpy import triangle
# call meshpy.triangle on our cleaned representation
info = triangle.MeshInfo()
info.set_points(arg['vertices'])
info.set_facets(arg['segments'])
# not all polygons have holes
if 'holes' in arg:
info.set_holes(arg['holes'])
# build mesh and pass kwargs to triangle
mesh = triangle.build(info, **kwargs)
# (n, 2) float vertices
vertices = np.array(mesh.points, dtype=np.float64)
# (m, 3) int faces
faces = np.array(mesh.elements, dtype=np.int64)
return vertices, faces
