from compas.datastructures import Network from compas.datastructures import Mesh import compas_rhino from compas.datastructures import network_find_cycles from compas_rhino.artists import MeshArtist from compas.datastructures import mesh_smooth_centroid # guids = compas_rhino.select_lines() # lines = compas_rhino.get_line_coordinates(guids) # network = Network.from_lines(lines) # cycles = network_find_cycles(network, network.leaves()) # vertices = [network.node_coordinates(vkey) for vkey in network.nodes()] # faces = cycles[1:] # mesh = Mesh.from_vertices_and_faces(vertices, faces) mesh = Mesh.from_obj('test6.obj') fixed = list(mesh.vertices_where({'vertex_degree': 3})) mesh_smooth_centroid(mesh, fixed=fixed) artist = MeshArtist(mesh) artist.draw_mesh()
key_index = mesh.key_index() V = mesh.vertices_attributes('xyz') F = [[key_index[key] for key in mesh.face_vertices(fkey)] for fkey in mesh.faces()] S = mesh.vertices_attribute('z') N = 50 vertices, levels = igl.trimesh_isolines(V, F, S, N) # ============================================================================== # Visualisation # ============================================================================== smin = min(S) smax = max(S) lines = [] for scalar, edges in levels: for i, j in edges: lines.append({ 'start' : vertices[i], 'end' : vertices[j], 'color' : i_to_rgb((scalar - smin) / (smax - smin)) }) artist = MeshArtist(mesh, layer="IGL::Isolines") artist.draw_faces() compas_rhino.draw_lines(lines, layer=artist.layer, clear=False)
from __future__ import absolute_import from __future__ import division from __future__ import print_function from compas.datastructures import Mesh from compas_rhino.artists import MeshArtist mesh = Mesh.from_json('cablenet.json') fabric = mesh.copy() fabric.name = 'fabric' # make a lookup dict for the vertex normals of the mesh vertices for key, attr in fabric.vertices(True): nx, ny, nz = key_normal[key] # update the attributes of the fabric vertices # to be offset in the normal direction by 2cm fabric.to_json('fabric.json') artist = MeshArtist(fabric, layer="Fabric") # clear the "Fabric" layer # draw the fabric as a mesh # specify a color for the mesh
from shapes import Polyhedron from compas_rhino.artists import MeshArtist from compas.datastructures import Mesh poly = Mesh.from_polyhedron(12) print(poly) artist = MeshArtist(poly, layer='00_my_mesh') artist.clear_layer() artist.draw_faces() artist.draw_mesh(join_faces=True)
block.attributes['blank'] = blank block.attributes['bottom'] = bottom blocks.append(block) # ============================================================================== # Export # ============================================================================== with open(FILE, 'w') as f: json.dump(blocks, f, cls=DataEncoder) # ============================================================================== # Visualize # ============================================================================== compas_rhino.clear_layers(["ITA20::Assignment1"]) for block in blocks: artist = MeshArtist(block, layer="ITA20::Assignment1::{}::Block".format( block.name)) artist.draw_faces(color={block.attributes['bottom']: (255, 0, 0)}) blank = block.attributes['blank'] artist = BoxArtist(blank, layer="ITA20::Assignment1::{}::Blank".format( block.name)) artist.draw(show_edges=True, show_faces=False)
import compas from compas.datastructures import Mesh from compas.datastructures import mesh_flatness from compas.utilities import i_to_rgb from compas_rhino.artists import MeshArtist from compas.rpc import Proxy TOL = 0.02 MAXDEV = 0.005 KMAX = 500 igl = Proxy('compas_libigl') mesh = Mesh.from_off(compas.get('tubemesh.off')) V, F = mesh.to_vertices_and_faces() V2 = igl.quadmesh_planarize((V, F), KMAX, MAXDEV) mesh = Mesh.from_vertices_and_faces(V2, F) dev = mesh_flatness(mesh, maxdev=TOL) artist = MeshArtist(mesh, layer="ITA20::Tubemesh") artist.clear_layer() artist.draw_faces(color={face: i_to_rgb(dev[face]) for face in mesh.faces()})
import random from compas.geometry import Pointcloud from compas.geometry import Translation, Rotation from compas.geometry import Box from compas.geometry import is_point_infront_plane from compas.datastructures import Mesh from compas_rhino.artists import PointArtist from compas_rhino.artists import MeshArtist pcl = Pointcloud.from_bounds(10, 5, 3, 100) box = Box.from_width_height_depth(2, 2, 2) T = Translation.from_vector([5, 2.5, 1.5]) R = Rotation.from_axis_and_angle([0, 0, 1], random.random() * math.pi) box.transform(T * R) mesh = Mesh.from_shape(box) colors = [] for point in pcl: colors.append((0, 0, 255)) PointArtist.draw_collection(pcl, colors=colors, layer="ITA20::PCL", clear=True) artist = MeshArtist(mesh, layer="ITA20::Box") artist.clear_layer() artist.draw_faces() artist.draw_edges()
points = [[WIRE, 0, 0], [WIRE, 0, HEIGHT], [WIRE, TABLE, HEIGHT], [WIRE, TABLE, 0]] polygon = Polygon(points) artist = PolygonArtist(polygon, layer="ITA20::HotWire::Right", color=(0, 255, 0)) artist.draw(show_edges=True, show_face=False) line = Line([0, 0, 0], [WIRE, 0, 0]) artist = LineArtist(line, color=(255, 255, 255), layer="ITA20::HotWire::Wire") artist.draw() # blank and block artist = MeshArtist(block, layer="ITA20::HotWire::Block") artist.draw_faces(color={left: (255, 0, 0), right: (0, 255, 0)}) artist = BoxArtist(blank, layer="ITA20::HotWire::Blank") artist.draw(show_edges=True, show_faces=False) # movement paths artist = PolylineArtist(left_poly, color=(255, 0, 0), layer="ITA20::HotWire::LeftCut") artist.draw() artist = PolylineArtist(right_poly, color=(0, 255, 0), layer="ITA20::HotWire::RightCut")
edges = list(mesh.edges()) # extract numerical data from the datastructure vertices = mesh.get_vertices_attributes(('x', 'y', 'z')) adjacency = [mesh.vertex_neighbors(key) for key in mesh.vertices()] fixed = [int(mesh.vertex_degree(key) == 2) for key in mesh.vertices()] # make a artist for (dynamic) visualization # and define a callback function # for plotting the intermediate configurations slider = list(mesh.vertices_where({'x': (-0.1, 0.1), 'y': (9.9, 10.1)}))[0] artist = MeshArtist(mesh, layer='SmoothMesh') artist.clear_layer() def callback(k, xyz): compas_rhino.wait() print(k) if k < kmax - 1: xyz[slider][0] = c_double(0.1 * (k + 1)) pointsconduit.points = [ mesh.vertex_coordinates(key) for key in mesh.vertices() ] linesconduit.lines = [mesh.edge_coordinates(u, v) for u, v in edges]
import compas from compas.datastructures import Mesh from compas_rhino.artists import MeshArtist mesh = Mesh.from_obj(compas.get('tubemesh.obj')) artist = MeshArtist(mesh) artist.draw_vertices() artist.draw_faces() artist.draw_edges()
# Visualization # ============================================================================== flag = False for i in frame_box_len_All_: if (flag == False): flag = True #artist = FrameArtist(frame, layer="SOUTH::Frame", scale=0.3) #artist.clear_layer() #artist.draw() artist = FrameArtist(i[0], layer="SOUTH::Frame1", scale=0.3) artist.clear_layer() artist.draw() artist = MeshArtist(i[1], layer="SOUTH::Bbox1") artist.clear_layer() artist.draw_mesh() else: #artist = FrameArtist(frame, layer="SOUTH::Frame", scale=0.3) #artist.draw() if (len(i) > 2): artist = FrameArtist(i[0], layer="SOUTH::Frame1", scale=0.3) artist.draw() artist = MeshArtist(i[1], layer="SOUTH::Bbox1") artist.draw_mesh() #artist.draw_vertexlabels() #PointArtist.draw_collection(allIntersections,layer="SOUTH::Intersection", clear=True)
# update default vertex attributes mesh.update_default_vertex_attributes({'px': 0.0, 'py': 0.0, 'pz': 0.0}) mesh.update_default_edge_attributes({'q': 1.0}) # numerical data xyz = mesh.get_vertices_attributes('xyz') edges = list(mesh.edges()) fixed = list(mesh.vertices_where({'vertex_degree': 2})) q = mesh.get_edges_attribute('q', 1.0) loads = mesh.get_vertices_attributes(('px', 'py', 'pz'), (0.0, 0.0, 0.0)) # call to fd_numpy over proxy server xyz, q, f, l, r = proxy.fd_numpy(xyz, edges, fixed, q, loads) # update the mesh vertices for key, attr in mesh.vertices(True): mesh.set_vertex_attributes(key, 'xyz', xyz[key]) mesh.set_vertex_attributes(key, ('rx', 'ry', 'rz'), r[key]) # update the mesh edges for index, (u, v, attr) in enumerate(mesh.edges(True)): attr['f'] = f[index][0] attr['l'] = l[index][0] # visualise the result artist = MeshArtist(mesh, layer="Mesh::FD") artist.clear_layer() artist.draw_vertices() artist.draw()
key_index = mesh.key_index() # convert data to a numerical format xyz = mesh.get_vertices_attributes('xyz') edges = [(key_index[u], key_index[v]) for u, v in mesh.edges()] fixed = [key_index[key] for key in mesh.vertices_where({'vertex_degree': 2})] q = mesh.get_edges_attribute('q', 1.0) loads = mesh.get_vertices_attributes(('px', 'py', 'pz'), (0.0, 0.0, 0.0)) # run the force density algorithm # through the proxy xyz, q, f, l, r = numerical.fd_numpy(xyz, edges, fixed, q, loads) # update the mesh with the result for key, attr in mesh.vertices(True): index = key_index[key] attr['x'] = xyz[index][0] attr['y'] = xyz[index][1] attr['z'] = xyz[index][2] for index, (u, v, attr) in enumerate(mesh.edges(True)): attr['f'] = f[index][0] attr['l'] = l[index][0] # visualise artist = MeshArtist(mesh, layer="ForceDensityNumpy") artist.clear_layer() artist.draw_vertices() artist.draw_edges() artist.draw_faces()
import os from compas.datastructures import Mesh from compas_rhino.artists import MeshArtist HERE = os.path.dirname(__file__) DATA = os.path.join(HERE, '../data') FILE = os.path.join(DATA, 'mesh.json') mesh = Mesh.from_json(FILE) artist = MeshArtist(mesh, layer="HiLo::Mesh") artist.clear_layer() artist.draw()
from compas.datastructures import Mesh from compas_rhino.artists import MeshArtist mesh = Mesh.from_json('cablenet.json') fabric = mesh.copy() fabric.name = 'fabric' # make a lookup dict for the vertex normals of the mesh vertices key_normal = {key: mesh.vertex_normal(key) for key in mesh.vertices()} for key, attr in fabric.vertices(True): nx, ny, nz = key_normal[key] # update the attributes of the fabric vertices # to be offset in the normal direction by 2cm attr['x'] += 0.02 * nx attr['y'] += 0.02 * ny attr['z'] += 0.02 * nz fabric.to_json('fabric.json') artist = MeshArtist(fabric, layer="Fabric") # clear the "Fabric" layer # draw the fabric as a mesh # specify a color for the mesh artist.clear_layer() artist.draw_mesh()
artist.draw_vertices(color={key: '#ff0000' for key in mesh.vertices_where({'is_fixed': True})}) artist.draw_edges() artist.redraw() # make a control mesh mesh = Mesh.from_polyhedron(6) # give the mesh a name mesh.attributes['name'] = 'Control' # set default vertex attributes mesh.update_default_vertex_attributes({'is_fixed': False}) # make an artist for visualisation artist = MeshArtist(mesh, layer='SubdModeling::Control') # draw the control mesh draw() # allow the user to change the attributes of the vertices while True: keys = VertexSelector.select_vertices(mesh) if not keys: break VertexModifier.update_vertex_attributes(mesh, keys) draw() # make a subd mesh (using catmullclark) subd = mesh_subdivide(mesh, scheme='catmullclark', k=4, fixed=mesh.vertices_where({'is_fixed': True}))
from __future__ import absolute_import from __future__ import division from __future__ import print_function from compas.datastructures import Mesh from compas_rhino.artists import MeshArtist mesh = Mesh.from_json('cablenet.json') vertexcolor = { key: (255, 0, 0) for key in mesh.vertices_where({'is_anchor': True}) } edgecolor = {key: (0, 0, 255) for key in mesh.edges_where({'is_joint': True})} artist = MeshArtist(mesh, layer="Cablenet") artist.clear_layer() artist.draw_vertices(color=vertexcolor) artist.draw_edges(color=edgecolor)
from compas.datastructures import Mesh from compas_assembly.datastructures import Assembly from compas_assembly.datastructures import assembly_hull # just so Rhino(Mac) gets the filepaths right HERE = os.path.dirname(__file__) # load an assembly from a JSON file assembly = Assembly.from_json( os.path.join(HERE, '../data/wall_interfaces.json')) # define a sequence of buildable blocks sequence = [28, 22, 23, 16, 17, 18, 11, 12, 13, 5, 6, 7, 8, 0, 1, 2, 3, 38] # hull of the sequence vertices, faces = assembly_hull(assembly, keys=sequence) hull = Mesh.from_vertices_and_faces(vertices, faces) # visualise artist = MeshArtist(hull, layer="Hull") artist.clear_layer() artist.draw() artist.redraw()
for fkey in edos.faces(): vertices = edos.face_vertices(fkey) if len(vertices) != 4: continue # normals of the cablenet # coordinates of the extrados # bottom face coordinates offset from vertex coordinates top = [] for point, normal in zip(bottom, normals): x = point[0] + 0.1 * normal[0] y = point[1] + 0.1 * normal[1] z = point[2] + 0.1 * normal[2] top.append([x, y, z]) # vertices and faces of the block block = Mesh.from_vertices_and_faces(vertices, faces) block.name = "Block.{}".format(fkey) blocks.append(block) # ============================================================================== # Visualize the blocks # ============================================================================== artist = MeshArtist(None, layer="Blocks")
boundary = rs.GetObject("Select Boundary Curve", 4) length = rs.GetReal("Select Edge Target Length", 2.0) points = rs.DivideCurve(boundary, rs.CurveLength(boundary) / length) # generate a delaunay triangulation # from the points on the boundary faces = delaunay_from_points(points, boundary=points) mesh = Mesh.from_vertices_and_faces(points, faces) # make a conduit for visualization conduit = MeshConduit(mesh, refreshrate=2) # run the remeshing algorithm # and draw the result with conduit.enabled(): trimesh_remesh( mesh, target=length, kmax=500, allow_boundary_split=True, allow_boundary_swap=True, callback=callback) artist = MeshArtist(mesh) artist.draw_faces(join_faces=True) artist.redraw()
for key, attr in mesh.vertices(True): attr['x'] = xyz[key][0] attr['y'] = xyz[key][1] attr['z'] = xyz[key][2] attr['rx'] = r[key][0] attr['ry'] = r[key][1] attr['rz'] = r[key][2] for index, (u, v, attr) in enumerate(mesh.edges(True)): attr['f'] = f[index][0] # ============================================================================== # Visualize result # ============================================================================== artist = MeshArtist(mesh, layer="Mesh") artist.clear_layer() artist.draw_vertices(color={ key: (255, 0, 0) for key in mesh.vertices_where({'is_fixed': True}) }) artist.draw_edges() artist.draw_faces() forces = [] for ..., ..., ... in mesh.edges(True): force = attr['...'] ...= mesh.vertex_coordinates(u) ...= mesh.vertex_coordinates(v) radius = 0.01 * force forces.append({
volume = idos.copy() volume.name = 'concrete1' # flip its cycles to make the bottom normals point downwards # set the key offset dkey = volume._max_int_key + 1 # add the vertices of the extrados for key, attr in edos.vertices(True): # add the faces of the extrados for fkey in edos.faces(): vertices = edos.face_vertices(fkey) # construct a polygon of boundary vertices # add the "side" faces # ============================================================================== # Export and visualisation # ============================================================================== # export volume.to_json('concrete1.json') # visualize artist = MeshArtist(volume, layer="Concrete1") artist.clear_layer() artist.draw_mesh(color=(0, 0, 255))
# ============================================================================== # Move the bunny to the origin and rotate it upright. # ============================================================================== vector = scale_vector(bunny.centroid(), -1) T = Translation.from_vector(vector) S = Scale.from_factors([100, 100, 100]) R = Rotation.from_axis_and_angle(Vector(1, 0, 0), math.radians(90)) bunny.transform(R * S * T) # ============================================================================== # Remesh # ============================================================================== num_edges = bunny.number_of_edges() length = sum(bunny.edge_length(*edge) for edge in bunny.edges()) / num_edges V, F = meshing.remesh(bunny.to_vertices_and_faces(), 2 * length, 10) bunny = Mesh.from_vertices_and_faces(V, F) # ============================================================================== # Visualize # ============================================================================== artist = MeshArtist(bunny, layer="CGAL::Remesh::Bunny") artist.clear_layer() artist.draw_faces(join_faces=True) artist.redraw()
# get input data srf_guid = rs.GetObject('Rhino surface to decompose', filter=8) or [] crv_guids = rs.GetObjects('Rhino curves to integrate', filter=4) or [] pt_guids = rs.GetObjects('Rhino points to integrate', filter=1) or [] discretisation = rs.GetReal( 'Value for precision - between 1 and 5 percent of scale', number=1, minimum=0) # get outer boundary polyline, inner boundary polylines, polyline features and point features by mapping curved surface to plan and discretising its boundaries and features outer_boundary, inner_boundaries, polyline_features, point_features = surface_discrete_mapping( srf_guid, discretisation, crv_guids=crv_guids, pt_guids=pt_guids) # Delaunay triangulation of the surface formed by the planar polylines using the points as Delaunay vertices mesh = boundary_triangulation(outer_boundary, inner_boundaries, polyline_features, point_features) # start instance for skeleton-based decomposition decomposition = SkeletonDecomposition.from_mesh(mesh) # build decomposition mesh mesh = decomposition.decomposition_mesh(point_features) # remap mesh on surface RhinoSurface.from_guid(srf_guid).mesh_uv_to_xyz(mesh) # draw decomposition mesh MeshArtist(mesh).draw_mesh()
# extract the input for the smoothing algorithm from the mesh # and identify the boundary as fixed vertices = mesh.vertices_attributes('xyz') faces = [mesh.face_vertices(fkey) for fkey in mesh.faces()] adjacency = [mesh.vertex_faces(key, ordered=True) for key in mesh.vertices()] fixed = set(mesh.vertices_on_boundary()) # run the smoothing algorithm smooth_area( vertices, faces, adjacency, fixed=fixed, kmax=50, callback=callback) # update the mesh for key, attr in mesh.vertices(True): attr['x'] = vertices[key][0] attr['y'] = vertices[key][1] attr['z'] = vertices[key][2] # visualize artist = MeshArtist(mesh, layer='mesh-out') artist.draw_faces(join_faces=True)
E = mesh.get_edges_attribute('E') radius = mesh.get_edges_attribute('radius') xyz, q, f, l, r = dr(vertices, edges, fixed, loads, qpre, fpre, lpre, linit, E, radius, kmax=100) for key, attr in mesh.vertices(True): index = k_i[key] attr['x'] = xyz[index][0] attr['y'] = xyz[index][1] attr['z'] = xyz[index][2] artist = MeshArtist(mesh, layer="XFunc::Mesh") artist.clear_layer() artist.draw_vertices() artist.draw_edges() artist.draw_faces() artist.redraw()
"""Assignment 01: Project box to xy-plane """ from compas.geometry import Box from compas.geometry import Frame, Plane from compas.geometry import Projection from compas_rhino.artists import BoxArtist from compas_rhino.artists import MeshArtist from compas.datastructures import Mesh # Define a Frame, which is not in the origin and a bit tilted to the world frame frame = Frame([1, 2, 3], [-0.45, 0.1, 0.3], [1, 2, 1]) # Create a Box with that frame box = Box(frame, 2, 3, 5) # Create a Projection (can be orthogonal, parallel or perspective) P = Projection.from_plane(Plane([0, 0, 0], [0, 0, 1])) # Create a Mesh from the Box mesh = Mesh.from_shape(box) # Apply the Projection onto the mesh mesh_projected = mesh.transformed(P) # Create artists artist1 = BoxArtist(box) artist2 = MeshArtist(mesh_projected) # Draw artist1.draw() artist2.draw_edges(color="#00ff00")
block = Mesh.from_vertices_and_faces(vertices, faces) blocks.append(block) all_vertices.extend(vertices) k = fkey * 8 faces_ = [[0+k, 3+k, 2+k, 1+k],[4+k, 5+k, 6+k, 7+k], [4+k, 0+k, 1+k, 5+k], [2+k, 6+k, 5+k, 1+k], [6+k, 2+k, 3+k, 7+k], [0+k, 4+k, 7+k, 3+k]] all_faces.extend(faces_) b = Cablenet.from_vertices_and_faces(all_vertices, all_faces) # ============================================================================== # Visualize # ============================================================================== #artist = MeshArtist(block, layer="Boxes::Test") #artist.clear_layer() #artist.draw_faces(join_faces=True,color=(0,255,255)) #artist.draw_vertexlabels() for i,block in enumerate(blocks): artist = MeshArtist(block, layer="Boxes::Test") if i == 0: artist.clear_layer() artist.draw_faces(join_faces=True,color=(0,255,255)) artist_2 = MeshArtist(b, layer="Boxes::Group") artist_2.clear_layer() artist_2.draw_faces(join_faces=True,color=(0,255,255)) b.to_json(FILE_O)
from compas.datastructures import Mesh from compas_rhino.artists import MeshArtist mesh = Mesh.from_json('cablenet.json') fabric = mesh.copy() fabric.name = 'fabric' # make a lookup dict for the vertex normals of the mesh vertices key_normal = {key: mesh.vertex_normal(key) for key in mesh.vertices()} for key, attr in fabric.vertices(True): nx, ny, nz = key_normal[key] # update the attributes of the fabric vertices # to be offset in the normal direction by 2cm attr['x'] += 0.02 * nx attr['y'] += 0.02 * ny attr['z'] += 0.02 * nz fabric.to_json('fabric.json') artist = MeshArtist(fabric, layer="Fabric") # clear the "Fabric" layer # draw the fabric as a mesh # specify a color for the mesh artist.clear_layer() artist.draw_mesh(color=(0, 255, 255))