def find_devisions(mesh, edge_groups, trg_len):
for edges in edge_groups:
lengths = 0
for u, v in edges:
lengths += mesh.get_edge_attribute((u, v), 'length')
ave_len = lengths / len(edges)
div = max((round(ave_len / trg_len, 0), 1))
for u, v in edges:
crv = mesh.get_edge_attribute((u, v), 'guid')
pts = rs.DivideCurve(crv, div)
mesh.set_edge_attribute((u, v), 'points', pts)
edges = set(mesh.edges())
coons_meshes = []
for fkey in mesh.faces():
if mesh.get_face_attribute(fkey, 'opening'):
continue
h_edges = mesh.face_halfedges(fkey)
# arrange point lists in circular order along edge faces
pts_coon = []
for h_edge in h_edges:
pts = mesh.get_edge_attribute(h_edge, 'points')[:]
if not h_edge in edges:
pts.reverse()
if not mesh.get_edge_attribute(h_edge, 'dir'):
pts.reverse()
pts_coon.append(pts)
# handle triangles correctly based on user input (flag 0 - 2)
if len(h_edges) == 4:
ab, bc, dc, ad = pts_coon
else:
flag = mesh.get_face_attribute(fkey, 'corner')
if flag == 0:
ab, bc, dc, ad = pts_coon[0], pts_coon[1], [], pts_coon[2]
elif flag == 1:
ab, bc, dc, ad = pts_coon[0], [], pts_coon[1], pts_coon[2]
elif flag == 2:
ab, bc, dc, ad = pts_coon[0], pts_coon[1], pts_coon[2], []
# reverse for coons patch (see parameters)
dc.reverse()
ad.reverse()
try: #this try except is a bit of a hack to make the openings work (needs revision)
vertices, faces = discrete_coons_patch(ab, bc, dc, ad)
coons_meshes.append(Mesh.from_vertices_and_faces(vertices, faces))
except:
pass
return coons_meshes
def discrete_coons_patch_mesh(mesh, ab, bc, dc, ad):
ab_xyz = [mesh.vertex_coordinates(vkey) for vkey in ab]
bc_xyz = [mesh.vertex_coordinates(vkey) for vkey in bc]
dc_xyz = [mesh.vertex_coordinates(vkey) for vkey in dc]
ad_xyz = [mesh.vertex_coordinates(vkey) for vkey in ad]
coons_vertices, coons_face_vertices = discrete_coons_patch(
ab_xyz, bc_xyz, dc_xyz, ad_xyz)
n = len(ab)
m = len(bc)
vertex_index_map = {}
for i, vkey in enumerate(ad):
vertex_index_map[i] = vkey
for i, vkey in enumerate(bc):
vertex_index_map[m * (n - 1) + i] = vkey
for i, vkey in enumerate(ab):
vertex_index_map[i * m] = vkey
for i, vkey in enumerate(dc):
vertex_index_map[m - 1 + i * m] = vkey
max_vkey = max(list(mesh.vertices()))
for i, vertex in enumerate(coons_vertices):
if i not in vertex_index_map:
max_vkey += 1
vertex_index_map[i] = max_vkey
mesh.add_vertex(max_vkey,
attr_dict={
xyz: value
for xyz, value in zip(['x', 'y', 'z'], vertex)
})
for face in coons_face_vertices:
mesh.add_face(list(reversed([vertex_index_map[vkey]
for vkey in face])))
def densification(self):
"""Generate a denser quad mesh from the coarse quad mesh and its strip densities.
"""
import time
t0 = time.time()
edge_strip = {}
for skey, edges in self.strips(data=True):
for edge in edges:
edge_strip[edge] = skey
edge_strip[tuple(reversed(edge))] = skey
t1 = time.time()
face_meshes = {}
for fkey in self.faces():
ab, bc, cd, da = [[
self.edge_point(
u, v,
float(i) /
float(self.get_strip_density(edge_strip[(u, v)])))
for i in range(0,
self.get_strip_density(edge_strip[(u, v)]) + 1)
] for u, v in self.face_halfedges(fkey)]
vertices, faces = discrete_coons_patch(ab, bc, list(reversed(cd)),
list(reversed(da)))
face_meshes[fkey] = QuadMesh.from_vertices_and_faces(
vertices, faces)
t2 = time.time()
self.set_quad_mesh(meshes_join_and_weld(face_meshes.values()))
#mesh = join_mesh(meshes)
# for u, v in self.edges():
# if not self.is_edge_on_boundary(u, v):
# fkey_0 = self.halfedge[u][v]
# fkey_1 = self.halfedge[v][u]
t3 = time.time()
print((t1 - t0) / (t3 - t0), (t2 - t1) / (t3 - t0),
(t3 - t2) / (t3 - t0))
def densification(self):
"""Generate a denser quad mesh from the coarse quad mesh and its strip densities.
"""
edge_strip = {}
for skey, edges in self.strips(data=True):
for edge in edges:
edge_strip[edge] = skey
edge_strip[tuple(reversed(edge))] = skey
meshes = []
for fkey in self.faces():
ab, bc, cd, da = [[
self.edge_point(
u, v,
float(i) /
float(self.get_strip_density(edge_strip[(u, v)])))
for i in range(0,
self.get_strip_density(edge_strip[(u, v)]) + 1)
] for u, v in self.face_halfedges(fkey)]
vertices, faces = discrete_coons_patch(ab, bc, list(reversed(cd)),
list(reversed(da)))
meshes.append(QuadMesh.from_vertices_and_faces(vertices, faces))
self.set_quad_mesh(meshes_join_and_weld(meshes))
new_sets_pts[2].reverse()
new_sets_pts[3].reverse()
return new_sets_pts
if __name__ == '__main__':
# division in both directions
div = 15
# select curves
crvs = rs.GetObjects("Select four curves (in cw order)", 4)
# divide curves
sets_pts = [rs.DivideCurve(crv, div) for crv in crvs]
# sort points
sets_pts = sort_pts(sets_pts)
# create coons patch
ab, bc, dc, ad = sets_pts
points, faces = discrete_coons_patch(ab, bc, dc, ad)
# create mesh object from points and faces
mesh = Mesh.from_vertices_and_faces(points, faces)
# draw coons mesh
artist = MeshArtist(mesh, layer='coons_mesh')
artist.draw()
def densification(self):
"""Generate a denser quad mesh from the coarse quad mesh and its strip densities.
Returns
-------
QuadMesh
A denser quad mesh.
"""
edge_strip = {}
for skey, edges in self.strips(data=True):
for edge in edges:
edge_strip[edge] = skey
edge_strip[tuple(reversed(edge))] = skey
pole_map = tuple([
geometric_key(self.vertex_coordinates(pole))
for pole in self.poles()
])
meshes = []
for fkey in self.faces():
polylines = [[
self.edge_point(
u, v,
float(i) /
float(self.get_strip_density(edge_strip[(u, v)])))
for i in range(0,
self.get_strip_density(edge_strip[(u, v)]) + 1)
] for u, v in self.face_halfedges(fkey)]
if self.is_face_pseudo_quad(fkey):
pole = self.data['attributes']['face_pole'][fkey]
idx = self.face_vertices(fkey).index(pole)
polylines.insert(idx, None)
ab, bc, cd, da = polylines
if cd is not None:
dc = list(reversed(cd))
else:
dc = None
if da is not None:
ad = list(reversed(da))
else:
ad = None
vertices, faces = discrete_coons_patch(ab, bc, dc, ad)
faces = [[u for u, v in pairwise(face + face[:1]) if u != v]
for face in faces]
mesh = PseudoQuadMesh.from_vertices_and_faces_with_face_poles(
vertices, faces)
meshes.append(mesh)
face_pole_map = {}
for mesh in meshes:
for fkey in mesh.faces():
for u, v in pairwise(
mesh.face_vertices(fkey) +
mesh.face_vertices(fkey)[:1]):
if geometric_key(mesh.vertex_coordinates(
u)) in pole_map and geometric_key(
mesh.vertex_coordinates(u)) == geometric_key(
mesh.vertex_coordinates(v)):
face_pole_map[geometric_key(
mesh.face_center(fkey))] = geometric_key(
mesh.vertex_coordinates(u))
break
self.set_quad_mesh(meshes_join_and_weld(meshes))
face_pole = {}
for fkey in self.get_quad_mesh().faces():
if geometric_key(
self.get_quad_mesh().face_center(fkey)) in face_pole_map:
for vkey in self.get_quad_mesh().face_vertices(fkey):
if geometric_key(self.get_quad_mesh().vertex_coordinates(
vkey)) == face_pole_map[geometric_key(
self.get_quad_mesh().face_center(fkey))]:
face_pole[fkey] = vkey
break
self.get_quad_mesh().data['attributes']['face_pole'] = face_pole
return self.get_quad_mesh()
