xyz, q, f, l, r = fd_numpy(vertices, edges, fixed, q, loads)
for vkey, coordinates in zip(sorted(list(mesh.vertices())), xyz):
mesh_move_vertex_to(mesh, coordinates, vkey)
def load_path(mesh):
return sum([mesh.edge_length(*edge) for edge in mesh.edges()])
def func(t, mesh, polyline_points):
fix_boundaries(mesh, polyline_points, t)
find_form(mesh)
return load_path(mesh)
mesh = Mesh.from_json('/Users/Robin/Desktop/simple_mesh.json')
mesh = conway_gyro(mesh)
polyline_points = [[2.6063381123514175, 40.935946423181882, 0.0],
[3.9369282045788494, 42.327616276045276, 0.0],
[5.760612811568148, 42.957179887931325, 0.0],
[7.677141583573143, 42.741476009840468, 0.0],
[9.249202441569466, 41.636074033399247, 0.0],
[10.099070540147636, 39.901842354098889, 0.0],
[10.445234328797181, 37.988992350564551, 0.0],
[10.832127422110238, 36.086128649415919, 0.0],
[12.034580052260155, 34.611669302310716, 0.0],
[13.872402034803775, 34.000898316364172, 0.0],
[15.793258601276873, 33.693072434788895, 0.0],
[17.697244927994845, 33.299890980625278, 0.0],
[19.435815699891037, 32.455904337698669, 0.0],
[20.426594142557271, 30.827275105478869, 0.0],
def from_skeleton(cls, lines, radius=1):
network = Network.from_lines(lines)
tube_extremities = {}
nodes = []
for vkey in network.vertices():
if len(network.vertex_neighbors(vkey)) > 1:
points = [
network.edge_point(vkey,
nbr,
t=float(radius) /
network.edge_length(vkey, nbr))
for nbr in network.vertex_neighbors(vkey)
]
faces = convex_hull(points)
mesh = cls.from_vertices_and_faces(points, faces)
meshes = []
for fkey in mesh.faces():
vertices = [
mesh.edge_midpoint(u, v)
for u, v in mesh.face_halfedges(fkey)
]
faces = [[0, 1, 2]]
meshes.append(cls.from_vertices_and_faces(vertices, faces))
for vkey_2 in mesh.vertices():
tops = []
bottoms = []
n = normalize_vector(
subtract_vectors(mesh.vertex_coordinates(vkey_2),
network.vertex_coordinates(vkey)))
for i in range(len(mesh.vertex_neighbors(vkey_2))):
pt_0 = mesh.edge_midpoint(
vkey_2,
mesh.vertex_neighbors(vkey_2, ordered=True)[i - 1])
bottoms.append(pt_0)
pt_1 = mesh.edge_midpoint(
vkey_2,
mesh.vertex_neighbors(vkey_2, ordered=True)[i])
pt_2 = midpoint_line([pt_0, pt_1])
pt_2 = add_vectors(
scale_vector(n, distance_point_point(pt_0, pt_1)),
pt_2)
tops.append(pt_2)
vertices = [pt_0, pt_2, pt_1]
faces = [[0, 1, 2]]
meshes.append(
cls.from_vertices_and_faces(vertices, faces))
for i in range(len(tops)):
vertices = [tops[i - 1], tops[i], bottoms[i]]
faces = [[0, 1, 2]]
meshes.append(
cls.from_vertices_and_faces(vertices, faces))
#print network.vertex_neighbors(vkey), network.vertex_neighbors(vkey)[vkey_2]
tube_extremities[(
vkey, network.vertex_neighbors(vkey)[vkey_2])] = tops
mesh = meshes_join_and_weld(meshes)
#dense_mesh = trimesh_subdivide_loop(mesh, k = 3)
nodes.append(mesh)
return nodes[0]
meshes_2 = []
for u, v in network.edges():
if len(network.vertex_neighbors(u)) > 1 and len(
network.vertex_neighbors(v)) > 1:
#print len(tube_extremities[(u, v)])
#print len(tube_extremities[(v, u)])
if len(tube_extremities[(u, v)]) == len(tube_extremities[(v,
u)]):
n = len(tube_extremities[(u, v)])
l = network.edge_length(u, v) - 2 * radius
m = math.floor(l / radius) + 1
pt_uv = tube_extremities[(u, v)]
pt_vu = list(reversed(tube_extremities[(v, u)]))
dmin = -1
imin = None
for i in range(n):
distance = sum([
distance_point_point(pt_uv[j],
pt_vu[i + j - len(pt_vu)])
for j in range(n)
])
if dmin < 0 or distance < dmin:
dmin = distance
imin = i
pt_vu = [pt_vu[imin + j - len(pt_vu)] for j in range(n)]
array = [pt_uv]
for i in range(int(m)):
polygon = []
for j in range(int(n)):
u = pt_uv[j]
v = pt_vu[j]
polygon.append(
add_vectors(
scale_vector(u, (float(m) - 1 - float(i)) /
float(m - 1)),
scale_vector(v,
float(i) / float(m - 1))))
array.append(polygon)
array.append(pt_vu)
#print len(array), len(array[0]), len(array[1]), len(array[2]), len(array[3])
for i in range(int(n)):
for j in range(int(m)):
vertices = [
array[i - 1][j - 1], array[i - 1][j],
array[i][j]
]
faces = [[0, 1, 2]]
meshes_2.append(
Mesh.from_vertices_and_faces(vertices, faces))
vertices, faces = join_and_weld_meshes(meshes_2)
#meshes_2 = rs.AddMesh(vertices, faces)
meshes = []
for node in nodes:
vertices, faces = node.to_vertices_and_faces()
meshes.append(rs.AddMesh(vertices, faces))
# (1, 2),
# (2, 3),
# (3, 4),
# (4, 5),
# (5, 0),
# (0, 3),
# (2, 5)
# ]
# adjacency = adjacency_from_edges(edges)
# print(adjacency)
# t0 = time.time()
# print(is_adjacency_two_colorable(adjacency))
# t1 = time.time()
# print(t1 - t0)
mesh = Mesh.from_obj(compas.get('faces.obj'))
t0 = time.time()
print(is_adjacency_two_colorable(mesh.adjacency))
t1 = time.time()
print(t1 - t0)
t0 = time.time()
print(vertex_coloring(mesh.adjacency))
t1 = time.time()
print(t1 - t0)
[0, 0, 0],
[1, 0, 0],
[2, 0, 0],
[3, 0, 0],
[3, 1, 0],
[0, 1, 0],
[0, 0.5, 0],
[0, 0.25, 0],
[4, 0, 0],
[4, 1, 0],
]
faces = [[0, 1, 2, 3, 4, 5, 6, 7], [3, 8, 9, 4]]
sources = [1, 2, 6, 7]
mesh = Mesh.from_vertices_and_faces(vertices, faces)
#quadrangulate_face(mesh, 0, sources)
quadrangulate_mesh(mesh, sources)
# for vkey in mesh.vertices():
# print 'vkey', vkey, mesh.vertex_faces(vkey)
# for fkey in mesh.faces():
# print 'fkey', fkey, mesh.face_vertices(fkey)
plotter = MeshPlotter(mesh)
plotter.draw_vertices(text='key')
plotter.draw_edges()
plotter.draw_faces(text='key')
plotter.show()
def from_quad_mesh(cls,
quad_mesh,
collect_strips=True,
collect_polyedges=True,
attribute_density=True):
"""Build coarse quad mesh from quad mesh with density and child-parent element data.
Parameters
----------
quad_mesh : QuadMesh
A quad mesh.
attribute_density : bool, optional
Keep density data of dense quad mesh and inherit it as aatribute.
Returns
----------
coarse_quad_mesh : CoarseQuadMesh
A coarse quad mesh with density data.
"""
polyedges = quad_mesh.singularity_polyedge_decomposition()
# vertex data
vertices = {
vkey: quad_mesh.vertex_coordinates(vkey)
for vkey in quad_mesh.vertices()
}
coarse_vertices_children = {
vkey: vkey
for polyedge in polyedges for vkey in [polyedge[0], polyedge[-1]]
}
coarse_vertices = {
vkey: quad_mesh.vertex_coordinates(vkey)
for vkey in coarse_vertices_children
}
# edge data
coarse_edges_children = {(polyedge[0], polyedge[-1]): polyedge
for polyedge in polyedges}
singularity_edges = [(x, y) for polyedge in polyedges
for u, v in pairwise(polyedge)
for x, y in [(u, v), (v, u)]]
# face data
faces = {
fkey: quad_mesh.face_vertices(fkey)
for fkey in quad_mesh.faces()
}
adj_edges = {(f1, f2)
for f1 in quad_mesh.faces()
for f2 in quad_mesh.face_neighbors(f1)
if f1 < f2 and quad_mesh.face_adjacency_halfedge(f1, f2)
not in singularity_edges}
coarse_faces_children = {}
for i, connected_faces in enumerate(
connected_components(adjacency_from_edges(adj_edges))):
mesh = Mesh.from_vertices_and_faces(
vertices, [faces[face] for face in connected_faces])
coarse_faces_children[i] = [
vkey for vkey in reversed(mesh.boundaries()[0])
if mesh.vertex_degree(vkey) == 2
]
coarse_quad_mesh = cls.from_vertices_and_faces(coarse_vertices,
coarse_faces_children)
# attribute relation child-parent element between coarse and dense quad meshes
coarse_quad_mesh.data['attributes'][
'vertex_coarse_to_dense'] = coarse_vertices_children
coarse_quad_mesh.data['attributes']['edge_coarse_to_dense'] = {
u: {}
for u in coarse_quad_mesh.vertices()
}
for (u, v), polyedge in coarse_edges_children.items():
coarse_quad_mesh.data['attributes']['edge_coarse_to_dense'][u][
v] = polyedge
coarse_quad_mesh.data['attributes']['edge_coarse_to_dense'][v][
u] = list(reversed(polyedge))
# collect strip and polyedge attributes
if collect_strips:
coarse_quad_mesh.collect_strips()
if collect_polyedges:
coarse_quad_mesh.collect_polyedges()
# store density attribute from input dense quad mesh
if attribute_density:
coarse_quad_mesh.set_strips_density(1)
for skey in coarse_quad_mesh.strips():
u, v = coarse_quad_mesh.strip_edges(skey)[0]
d = len(
coarse_edges_children.get((u, v),
coarse_edges_children.get((v, u),
[])))
coarse_quad_mesh.set_strip_density(skey, d)
# store quad mesh and use as polygonal mesh
coarse_quad_mesh.set_quad_mesh(quad_mesh)
coarse_quad_mesh.set_polygonal_mesh(quad_mesh.copy())
return coarse_quad_mesh