def test_from_lines():
with open(compas.get('lines.json'), 'r') as fo:
lines = json.load(fo)
mesh = Mesh.from_lines(lines)
assert mesh.number_of_faces() == 10
assert mesh.number_of_vertices() == 32
assert mesh.number_of_edges() == 40
def get_initial_mesh(precision):
crvs = rs.GetObjects("Select boundary curves",
4,
group=True,
preselect=False,
select=False,
objects=None,
minimum_count=3,
maximum_count=0)
lines = get_line_coordinates(crvs)
geo_lines = [(geometric_key(pt_u,
precision), geometric_key(pt_v, precision))
for pt_u, pt_v in lines]
network = Network.from_lines(lines, precision)
if network.leaves():
return None
adjacency = {
key: network.vertex_neighbors(key)
for key in network.vertices()
}
root = network.get_any_vertex()
ordering, predecessors, paths = depth_first_tree(adjacency, root)
if len(ordering) != network.number_of_vertices():
return None
mesh = Mesh.from_lines(lines,
delete_boundary_face=True,
precision=precision)
for u, v, attr in mesh.edges(True):
pt_u, pt_v = mesh.edge_coordinates(u, v)
geo_u, geo_v = geometric_key(pt_u, precision), geometric_key(
pt_v, precision)
for i, geo_l_uv in enumerate(geo_lines):
geo_l_u, geo_l_v = geo_l_uv[0], geo_l_uv[1]
if (geo_l_u == geo_u) and (geo_l_v == geo_v):
attr['dir'] = True
elif (geo_l_u == geo_v) and (geo_l_v == geo_u):
attr['dir'] = False
else:
continue
attr['guid'] = str(crvs[i])
attr['length'] = rs.CurveLength(crvs[i])
# initiate flag for corners
for fkey, attr in mesh.faces(True):
mesh.set_face_attribute(fkey, 'corner', 0)
mesh.set_face_attribute(fkey, 'opening', 0)
return mesh
rgb = i_to_rgb(flat_vals[i])
rs.ObjectColor(srfs[-1], rgb)
rs.AddObjectsToGroup(srfs, rs.AddGroup())
# refresh viewport
rs.EnableRedraw(True)
if __name__ == '__main__':
thickness = 0.2
edge_crvs = rs.GetObjects("Select edges", 4)
lines = get_line_coordinates(edge_crvs)
mesh = Mesh.from_lines(lines, delete_boundary_face=True)
# compute offset points top (a)
vertices_list = []
key_index_a = {}
for i, key in enumerate(mesh.vertices()):
pt = mesh.vertex_coordinates(key)
normal = mesh.vertex_normal(key)
vertices_list.append(
add_vectors(pt, scale_vector(normal, thickness * .5)))
# create key_index map top (a)
key_index_a[key] = i
# compute offset points bottom (b)
n = mesh.number_of_vertices()
key_index_b = {}
def get_initial_mesh(precision):
crvs = rs.GetObjects("Select boundary curves",
4,
group=True,
preselect=False,
select=False,
objects=None,
minimum_count=3,
maximum_count=0)
lines = get_line_coordinates(crvs)
geo_lines = [(geometric_key(pt_u,
precision), geometric_key(pt_v, precision))
for pt_u, pt_v in lines]
network = Network.from_lines(lines, precision)
if network.leaves():
return None
adjacency = {
key: network.vertex_neighbours(key)
for key in network.vertices()
}
root = network.get_any_vertex()
ordering, predecessors, paths = depth_first_tree(adjacency, root)
if len(ordering) != network.number_of_vertices():
return None
mesh = Mesh.from_lines(lines,
delete_boundary_face=True,
precision=precision)
rs.EnableRedraw(False)
dots = {}
for fkey in mesh.faces():
cent = mesh.face_centroid(fkey)
dot = rs.AddTextDot('', cent)
rs.TextDotHeight(dot, 6)
dots[str(dot)] = fkey
rs.EnableRedraw(True)
if not dots:
return None
dot_ids = dots.keys()
data = rs.GetObjectsEx(message="Select face for openings",
filter=0,
preselect=False,
select=False,
objects=dot_ids)
rs.DeleteObjects(dot_ids)
if data:
for datum in data:
dot = datum[0]
fkey = dots[str(dot)]
mesh.delete_face(fkey)
geo_edges = []
for u, v, attr in mesh.edges(True):
pt_u, pt_v = mesh.edge_coordinates(u, v)
geo_u, geo_v = geometric_key(pt_u, precision), geometric_key(
pt_v, precision)
for i, geo_l_uv in enumerate(geo_lines):
geo_l_u, geo_l_v = geo_l_uv[0], geo_l_uv[1]
if (geo_l_u == geo_u) and (geo_l_v == geo_v):
attr['dir'] = True
elif (geo_l_u == geo_v) and (geo_l_v == geo_u):
attr['dir'] = False
else:
continue
attr['guid'] = str(crvs[i])
attr['length'] = rs.CurveLength(crvs[i])
# initiate flag for corners
for fkey, attr in mesh.faces(True):
mesh.set_face_attribute(fkey, 'corner', 0)
return mesh, crvs
4,
group=True,
preselect=False,
select=False,
objects=None)
#----------------------------------------
#----------------------------------------
#create a inital mesh from the boundary and crease curves
lines = get_line_coordinates(crvs)
geo_lines = [(geometric_key(pt_u,
precision), geometric_key(pt_v, precision))
for pt_u, pt_v in lines]
mesh = Mesh.from_lines(lines,
delete_boundary_face=True,
precision=precision)
#assign curve guids to mesh edges
for u, v, attr in mesh.edges(True):
pt_u, pt_v = mesh.edge_coordinates(u, v)
geo_u, geo_v = geometric_key(pt_u, precision), geometric_key(
pt_v, precision)
for i, geo_l_uv in enumerate(geo_lines):
geo_l_u, geo_l_v = geo_l_uv[0], geo_l_uv[1]
if (geo_l_u == geo_u) and (geo_l_v == geo_v) or (
geo_l_u == geo_v) and (geo_l_v == geo_u):
attr['guid'] = str(crvs[i])
break
#compute ordered polygons per face
for fkey, attr in mesh.faces(True):
def test_from_lines():
lines = compas.json_load(compas.get('lines.json'))
mesh = Mesh.from_lines(lines)
assert mesh.number_of_faces() == 10
assert mesh.number_of_vertices() == 32
assert mesh.number_of_edges() == 40
from compas.datastructures import Mesh
# from compas.files import OBJ
# filepath = compas.get('lines.obj')
# obj = OBJ(filepath)
# vertices = obj.parser.vertices
# edges = obj.parser.lines
# lines = [(vertices[u], vertices[v], 0) for u, v in edges]
# form = FormDiagram.from_lines(lines, delete_boundary_face=False)
# mesh = Mesh.from_obj(compas.get('faces.obj'))
# height = 5.0
# mesh.set_vertices_attribute('z', height)
# form = FormDiagram.from_mesh(mesh)
# assert form.number_of_faces() == mesh.number_of_faces()
# assert form.number_of_vertices() == mesh.number_of_vertices()
# assert max(mesh.get_vertices_attribute('z')) - height == max(form.get_vertices_attribute('z'))
# form.plot()
points = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [2.0, 0.0, 0.0],
[3.0, 0.0, 0.0], [4.0, 0.0, 0.0]]
lines = [(0, 1), (1, 2), (2, 3), (3, 4)]
mesh = Mesh.from_lines([(points[u], points[v]) for u, v in lines])
print(mesh.summary())
