def clear_layer(self):
"""Clear the main layer of the artist.
Returns
-------
None
"""
if self.layer:
compas_rhino.clear_layer(self.layer)
else:
compas_rhino.clear_current_layer()
def draw_mesh_as_faces(mesh,
layer=None,
clear_layer=False,
facecolor=None,
redraw=True):
guids = compas_rhino.get_objects(
name='{0}.*'.format(mesh.attributes['name']))
compas_rhino.delete_objects(guids)
if clear_layer:
if not layer:
compas_rhino.clear_current_layer()
else:
compas_rhino.clear_layer(layer)
facecolor = facecolor or {}
meshes = []
for fkey in mesh.faces():
vertices = mesh.face_coordinates(fkey)
faces = [range(len(vertices))]
color = facecolor.get(fkey, (255, 255, 255))
guid = compas_rhino.xdraw_mesh(vertices,
faces,
None,
'{0}.face.{1}'.format(
mesh.attributes['name'], fkey),
layer=layer,
clear=False,
redraw=False)
compas_rhino.set_mesh_vertex_colors(
guid, [color for i in range(len(vertices))])
meshes.append(guid)
if layer:
previous = rs.CurrentLayer(layer)
guid = rs.JoinMeshes(meshes, delete_input=True)
if layer:
rs.CurrentLayer(previous)
rs.ObjectName(guid, '{0}'.format(mesh.attributes['name']))
rs.EnableRedraw()
rs.Redraw()
def clear_layer(self):
"""Clear the main layer of the artist."""
if self.settings['layer']:
compas_rhino.clear_layer(self.settings['layer'])
else:
compas_rhino.clear_current_layer()
def draw_mesh(
mesh,
layer=None,
clear_layer=False,
show_faces=True,
show_vertices=False,
show_edges=False,
show_wireframe=False,
vertexcolor=None,
edgecolor=None,
wireframecolor=None,
facecolor=None,
):
"""
Draw a mesh object in Rhino.
Parameters:
mesh (compas.datastructures.mesh.Mesh): The mesh object.
layer (str): Optional. The layer to draw in. Default is ``None``.
clear_layer (bool): Optional. Clear the drawing layer. Default is ``True``.
show_faces (bool): Optional. Show the faces. Default is ``True``.
show_vertices (bool): Optional. Show the vertices. Default is ``True``.
show_edges (bool): Optional. Show the edges. Default is ``True``.
vertexcolor (str, tuple, list, dict): Optional. The vertex color specification. Default is ``None``.
edgecolor (str, tuple, list, dict): Optional. The edge color specification. Default is ``None``.
facecolor (str, tuple, list, dict): Optional. The face color specification. Default is ``None``.
redraw (bool): Optional. Redraw instructions. Default is ``True``.
Note:
Colors can be specifiedin different ways:
* str: A hexadecimal color that will be applied to all elements subject to the specification.
* tuple, list: RGB color that will be applied to all elements subject to the specification.
* dict: RGB or hex color dict with a specification for some or all of the related elements.
Important:
RGB colors should specify color values between 0 and 255.
"""
vertexcolor = color_to_colordict(vertexcolor,
mesh.vertices(),
default=mesh.attributes['color.vertex'],
colorformat='rgb',
normalize=False)
edgecolor = color_to_colordict(edgecolor,
mesh.edges(),
default=mesh.attributes['color.edge'],
colorformat='rgb',
normalize=False)
# facecolor = color_to_colordict(facecolor,
# mesh.faces(),
# default=mesh.attributes['color.face'],
# colorformat='rgb',
# normalize=False)
guids = compas_rhino.get_objects(
name='{0}.*'.format(mesh.attributes['name']))
compas_rhino.delete_objects(guids)
if clear_layer:
if not layer:
compas_rhino.clear_current_layer()
else:
compas_rhino.clear_layer(layer)
if show_faces:
key_index = {key: index for index, key in enumerate(mesh.vertices())}
xyz = [mesh.vertex_coordinates(key) for key in mesh.vertices()]
faces = []
color = mesh.attributes['color.face']
for fkey in mesh.face:
face = mesh.face_vertices(fkey, ordered=True)
v = len(face)
if v < 3:
print('Degenerate face: {0} => {1}'.format(fkey, face))
elif v == 3:
faces.append([key_index[k] for k in face + [face[-1]]])
elif v == 4:
faces.append([key_index[k] for k in face])
else:
c = len(xyz)
xyz.append(mesh.face_center(fkey))
for i in range(-1, len(face) - 1):
key = face[i]
nbr = face[i + 1]
vertices = [
c, key_index[key], key_index[nbr], key_index[nbr]
]
faces.append(vertices)
compas_rhino.xdraw_mesh(xyz,
faces,
color,
'{0}.mesh'.format(mesh.attributes['name']),
layer=layer,
clear=False,
redraw=False)
if show_edges:
lines = []
color = mesh.attributes['color.edge']
for u, v in mesh.edges():
lines.append({
'start':
mesh.vertex_coordinates(u),
'end':
mesh.vertex_coordinates(v),
'name':
'{0}.edge.{1}-{2}'.format(mesh.attributes['name'], repr(u),
repr(v)),
'color':
edgecolor.get((u, v), color),
})
compas_rhino.xdraw_lines(lines, layer=layer, clear=False, redraw=False)
if show_wireframe:
lines = []
color = mesh.attributes['color.edge']
for u, v in mesh.wireframe():
lines.append({
'start':
mesh.vertex_coordinates(u),
'end':
mesh.vertex_coordinates(v),
'name':
'{0}.edge.{1}-{2}'.format(mesh.attributes['name'], repr(u),
repr(v)),
'color':
edgecolor.get((u, v), color),
})
compas_rhino.xdraw_lines(lines, layer=layer, clear=False, redraw=False)
if show_vertices:
points = []
color = mesh.attributes['color.vertex']
for key in mesh.vertices():
points.append({
'pos':
mesh.vertex_coordinates(key),
'name':
'{0}.vertex.{1}'.format(mesh.attributes['name'], repr(key)),
'color':
vertexcolor.get(key, color),
})
compas_rhino.xdraw_points(points,
layer=layer,
clear=False,
redraw=False)
rs.EnableRedraw()
rs.Redraw()
