def mesh_draw_vertices(mesh,
keys=None,
color=None):
"""Draw a selection of vertices of the mesh.
Parameters
----------
mesh : :class:`compas.datastructures.Mesh`
A mesh object.
keys : list (None)
A list of vertex keys identifying which vertices to draw.
Default is to draw all vertices.
color : str, tuple, dict (None)
The color specififcation for the vertices.
Colors should be specified in the form of a string (hex colors) or as a tuple of RGB components.
To apply the same color to all vertices, provide a single color specification.
Individual colors can be assigned using a dictionary of key-color pairs.
Missing keys will be assigned the default vertex color (``self.defaults['vertex.color']``).
Default is use the color of the parent layer.
Notes
-----
The vertices are named using the following template: ``"{mesh.name}.vertex.{id}"``.
This name can be used afterwards to identify vertices of the mesh in the Rhino model.
Examples
--------
>>>
"""
artist = MeshArtist(mesh)
return artist.draw_vertices(keys, color)
def mesh_draw(mesh, color=None):
"""
Draw a mesh object in Rhino.
Parameters
----------
mesh : compas.datastructures.Mesh
The mesh object.
color : str, tuple, list, dict (None)
The vertex color specification.
Defaults to None.
Notes
-----
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.
Notes
-----
RGB colors specified as values between 0 and 255, should be integers.
RGB colors specified as values between 0.0 and 1.0, should be floats.
"""
artist = MeshArtist(mesh)
return artist.draw_mesh(color)
def mesh_draw_faces(mesh,
keys=None,
color=None,
join_faces=False):
"""Draw a selection of faces of the mesh.
Parameters
----------
keys : list (None)
A list of face keys identifying which faces to draw.
Default is to draw all faces.
join_faces : bool (False)
Join the faces into a polymesh object.
Notes
-----
The faces are named using the following template: ``"{mesh.name}.face.{id}"``.
Examples
--------
>>>
"""
artist = MeshArtist(mesh)
return artist.draw_faces(keys, color, join_faces)
def to_rgmesh(self):
"""Convert to :class:`Rhino.Geometry.Mesh`
Returns
-------
:class:`Rhino.Geometry.Mesh`
"""
artist = MeshArtist(self)
return artist.draw_mesh()
def grasshopper_draw(self):
visualisations = []
for woodLayer in self.timberboards:
for board in woodLayer:
my_box = board.box
mesh_box = Mesh.from_shape(my_box)
artist = MeshArtist(mesh_box)
box_visualisation = artist.draw_mesh()
visualisations.append(box_visualisation)
return visualisations
def grasshopper_draw():
visualisations = []
for brd in self.elements():
board = brd[1]
# visualise all the boards
my_box = box_update(board)[1]
mesh_box = Mesh.from_shape(my_box)
artist = MeshArtist(mesh_box)
box_visualisation = artist.draw_mesh()
visualisations.append(box_visualisation)
return visualisations
def load_slicer(path, folder_name, json_name):
""" Loads slicer data. """
data = load_json_file(path, folder_name, json_name)
mesh = None
paths_nested_list = []
are_closed = []
all_points = []
if data:
if 'mesh' in data:
compas_mesh = Mesh.from_data(data['mesh'])
artist = MeshArtist(compas_mesh)
mesh = artist.draw()
else:
print('No mesh has been saved in the json file.')
if 'layers' in data:
layers_data = data['layers']
for i in range(len(layers_data)):
paths_nested_list.append(
[]) # save each layer on a different list
layer_data = layers_data[str(i)]
paths_data = layer_data['paths']
for j in range(len(paths_data)):
path_data = paths_data[str(j)]
pts = []
are_closed.append(path_data['is_closed'])
if len(path_data['points']
) > 2: # ignore smaller curves that throw errors
for k in range(len(path_data['points'])):
pt = path_data['points'][str(k)]
pt = rs.AddPoint(pt[0], pt[1],
pt[2]) # re-create points
pts.append(pt)
all_points.extend(pts)
path = rs.AddPolyline(pts)
paths_nested_list[-1].append(path)
else:
print(
'No layers have been saved in the json file. Is this the correct json?'
)
print('The slicer contains %d layers. ' % len(paths_nested_list))
paths_nested_list = list_to_ghtree(paths_nested_list)
return mesh, paths_nested_list, are_closed, all_points
def grasshopper_draw(system):
def box_update(elmnt):
elmnt.board_frame = Frame(elmnt.centre_point, elmnt.length_vector, elmnt.width_vector)
elmnt.box = Box(elmnt.board_frame, elmnt.length, elmnt.width, elmnt.height)
return elmnt.board_frame, elmnt.box
visualisations = []
for brd in system.elements():
board = brd[1]
# visualise all the boards
my_box = box_update(board)[1]
mesh_box = Mesh.from_shape(my_box)
artist = MeshArtist(mesh_box)
box_visualisation = artist.draw_mesh()
visualisations.append(box_visualisation)
return visualisations
def load_multiple_meshes(starts_with, ends_with, path, folder_name):
""" Load all the meshes that have the specified name, and print them in different colors. """
filenames = get_files_with_name(starts_with, ends_with,
os.path.join(path, folder_name, 'output'))
meshes = [
Mesh.from_obj(os.path.join(path, folder_name, 'output', filename))
for filename in filenames
]
loaded_meshes = []
for i, m in enumerate(meshes):
artist = MeshArtist(m)
color = get_color(i, total=len(meshes))
mesh = artist.draw(color)
loaded_meshes.append(mesh)
return loaded_meshes
def RunScript(self, robot, group, configuration, attached_collision_meshes,
show_visual, show_collision, show_frames, show_base_frame,
show_end_effector_frame, show_acm):
visual = None
collision = None
attached_meshes = None
frames = None
base_frame = None
ee_frame = None
if robot:
show_visual = True if show_visual is None else show_visual
configuration = configuration or robot.zero_configuration()
robot.update(configuration,
visual=show_visual,
collision=show_collision)
compas_frames = robot.transformed_frames(configuration, group)
if show_visual:
visual = robot.artist.draw_visual()
if show_collision:
collision = robot.artist.draw_collision()
if show_base_frame:
base_compas_frame = compas_frames[0]
artist = FrameArtist(base_compas_frame)
base_frame = artist.draw()
if show_end_effector_frame:
ee_compas_frame = robot.forward_kinematics(
configuration, group, options=dict(solver='model'))
artist = FrameArtist(ee_compas_frame)
ee_frame = artist.draw()
if show_frames:
frames = []
for compas_frame in compas_frames[1:]:
artist = FrameArtist(compas_frame)
frame = artist.draw()
frames.append(frame)
if show_acm:
attached_meshes = []
for acm in attached_collision_meshes:
frame = robot.forward_kinematics(configuration,
options=dict(
solver='model',
link=acm.link_name))
T = Transformation.from_frame_to_frame(
acm.collision_mesh.frame, frame)
mesh = acm.collision_mesh.mesh.transformed(T)
attached_meshes.append(MeshArtist(mesh).draw())
return (visual, collision, attached_meshes, frames, base_frame,
ee_frame)
def get_rgmesh(self, face_count=18):
"""Generate mesh representation of bullet with custom resolution.
Parameters
----------
face_count : :class:`int`, optional
Desired number of faces, by default 18
Used as a guide for the resolution of the mesh cylinder
Returns
-------
:class:`Rhino.Geometry.Mesh`
"""
mesh = self.get_cgmesh(face_count=face_count)
# to Rhino.Geometry and clean it up
rgmesh = MeshArtist(mesh).draw_mesh()
rgmesh.UnifyNormals()
rgmesh.Normals.ComputeNormals()
return rgmesh
def mesh_draw_edges(mesh, keys=None, color=None):
"""Draw a selection of edges of the mesh.
Parameters
----------
keys : list
A list of edge keys (as uv pairs) identifying which edges to draw.
Default is to draw all edges.
Notes
-----
All edges are named using the following template:
``"{}.edge.{}-{}".fromat(self.mesh.attributes['name'], u, v)``.
Examples
--------
>>> mesh_draw_edges(mesh)
>>> mesh_draw_edges(mesh, keys=mesh.edges_on_boundary())
"""
artist = MeshArtist(mesh)
return artist.draw_edges(keys, color)
def receive_mesh(message):
mesh_message = Mesh.from_msg(message)
artist = MeshArtist(mesh_message.mesh)
sc.doc = Rhino.RhinoDoc.ActiveDoc
sc.doc.Objects.AddMesh(artist.draw())
sc.doc = ghdoc
# Ghpython
import compas
from compas.datastructures import Mesh
from compas_ghpython.artists import MeshArtist
mesh = Mesh.from_obj(compas.get('hypar.obj'))
artist = MeshArtist(mesh)
a = artist.draw()
from __future__ import print_function
from __future__ import division
from compas.datastructures import Mesh
from compas.datastructures import mesh_subdivide
from compas_ghpython.artists import MeshArtist
# make a control mesh
mesh = Mesh.from_polyhedron(6)
# set default vertex attributes
mesh.update_default_vertex_attributes({'is_fixed': False})
# make an artist for drawing
artist = MeshArtist(mesh)
# draw the control mesh into outputs P, L
P = artist.draw_vertices()
L = artist.draw_edges()
# keep some of the vertices fixed and make a subd mesh (using catmullclark)
for key, value in zip(range(len(is_fixed)), is_fixed):
mesh.set_vertex_attribute(key, 'is_fixed', value)
fixed = mesh.vertices_where({'is_fixed': True})
subd = mesh_subdivide(mesh, scheme='catmullclark', k=k, fixed=fixed)
# pass the new mesh to the artist
artist.mesh = subd
def get_rgmesh(self, face_count=18):
"""Generate mesh representation of bullet with custom resolution.
Parameters
----------
face_count : :class:`int`, optional
Desired number of faces, by default 18
Used as a guide for the resolution of the mesh cylinder
Returns
-------
:class:`Rhino.Geometry.Mesh`
"""
import Rhino.Geometry as rg
if face_count < 6:
sides = 3
elif face_count < 15:
sides = 4
else:
sides = face_count // 3
circle = self.get_rgcircle()
polygons = []
polygons.append(rg.Polyline.CreateInscribedPolygon(circle, sides))
T = rg.Transform.Translation(circle.Normal *
-self.get_compressed_height())
second_polygon = polygons[0].Duplicate()
second_polygon.Transform(T)
polygons.append(second_polygon)
mesh = cg_Mesh()
outer_verts_polygons = []
# generate verts at polygon corners
for polygon in polygons:
_temp_list = []
polygon_corners = list(polygon.Item)
polygon_corners.pop() # remove end pt since == start pt
for pt in polygon_corners:
_temp_list.append(mesh.add_vertex(x=pt.X, y=pt.Y, z=pt.Z))
outer_verts_polygons.append(_temp_list)
polygon_faces = []
for vkeys in outer_verts_polygons:
polygon_faces.append(mesh.add_face(vkeys))
# if >4 sides polygon, create faces by tri subd
if sides > 4:
centroid_verts = []
for fkey in polygon_faces:
x, y, z = mesh.face_centroid(fkey)
centroid_verts.append(mesh.add_vertex(x=x, y=y, z=z))
mesh.delete_face(fkey)
# create new faces
for vkeys, ckey in zip(outer_verts_polygons, centroid_verts):
for i, vkey in enumerate(vkeys):
next_vkey = wrap_list(vkeys, i + 1)
mesh.add_face([ckey, vkey, next_vkey])
# generate faces between polygons
vertex_for_vertex = zip(*outer_verts_polygons)
for i, mirror_corners_1 in enumerate(vertex_for_vertex):
mirror_corners_2 = wrap_list(vertex_for_vertex, i + 1)
mesh.add_face(mirror_corners_1 + mirror_corners_2[::-1])
# to Rhino.Geometry and clean it up
rgmesh = MeshArtist(mesh).draw_mesh()
rgmesh.UnifyNormals()
rgmesh.Normals.ComputeNormals()
return rgmesh
def draw(self):
from compas_ghpython.artists import MeshArtist
for vkey, element in self.assembly.elements():
artist = MeshArtist(element.mesh)
yield artist.draw_mesh()
def cgmesh_to_rgmesh(mesh):
artist = MeshArtist(mesh)
return artist.draw_mesh()
