def meshExtrudePolyToByVectPlane(poly, vect, pln):
extrudeVect = vect
#find far line from vector to be intersected later
farvect = rs.VectorScale(extrudeVect, 1000)
pts = rs.CurveEditPoints(poly)
meshes = []
for i in range(0, len(pts) - 1):
p1 = pts[i]
p2 = pts[i + 1]
line = [p1, p1 + farvect]
p1pj = rs.LinePlaneIntersection(line, pln)
line = [p2, p2 + farvect]
p2pj = rs.LinePlaneIntersection(line, pln)
m = addMeshQuad([p1, p1pj, p2pj, p2])
meshes.append(m)
pjPolyPts = []
for p in pts:
line = [p, p + farvect]
xp = rs.LinePlaneIntersection(line, pln)
pjPolyPts.append(xp)
mesh = rs.JoinMeshes(meshes, True)
return mesh, pjPolyPts
def meshSwipPolyAlongPoly(profile, rail):
profile = rs.CopyObject(profile)
pts = rs.CurveEditPoints(rail)
baseVect = Rhino.Geometry.Point3d(0, 1, 0)
meshes = []
for i in range(0, len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
rv1 = rs.VectorUnitize(p0 - p1)
vect = p1 - p0
mid = rs.VectorUnitize((rv1 + v2) / 2)
np = p1 + mid
up = p1 + Rhino.Geometry.Point3d(0, 0, 1)
pln = rs.PlaneFromPoints(p1, np, up)
mesh, pjpts = meshExtrudePolyToByVectPlane(profile, vect, pln)
meshes.append(mesh)
rs.DeleteObject(profile)
profile = rs.AddPolyline(pjpts)
mesh = rs.JoinMeshes(meshes, True)
rs.DeleteObject(profile)
return mesh
def construct_mesh_center(points):
meshes = []
### calc center point
bbox = rs.BoundingBox(points)
line = rs.AddLine(bbox[0], bbox[6])
c = rs.CurveMidPoint(line)
### set new point list
points.append(c)
###
c_index = len(points) - 1
# print(c_index)
for j in xrange(len(points) - 1):
if j < (len(points) - 2):
vertex_ = [(c_index, int(j), int(j) + 1, int(j) + 1)]
# print(vertex_)
m = rs.AddMesh(points, vertex_)
meshes.append(m)
else:
vertex_ = [(c_index, int(j), 0, 0)]
# print(vertex_)
m = rs.AddMesh(points, vertex_)
meshes.append(m)
mesh_joined = rs.JoinMeshes(meshes)
return mesh_joined
def draw_faces(self, keys=None, color=None, join_faces=False):
"""Draw a selection of faces.
Parameters
----------
fkeys : list
A list of face keys identifying which faces to draw.
The default is ``None``, in which case all faces are drawn.
color : str, tuple, dict
The color specififcation for the faces.
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 faces, provide a single color
specification. Individual colors can be assigned using a dictionary
of key-color pairs. Missing keys will be assigned the default face
color (``self.defaults['face.color']``).
The default is ``None``, in which case all faces are assigned the
default face color.
Notes
-----
The faces are named using the following template:
``"{}.face.{}".format(self.datastructure.name, key)``.
This name is used afterwards to identify faces in the Rhino model.
"""
keys = keys or list(self.datastructure.faces())
colordict = color_to_colordict(color,
keys,
default=self.defaults.get('color.face'),
colorformat='rgb',
normalize=False)
faces = []
for fkey in keys:
faces.append({
'points':
self.datastructure.face_coordinates(fkey),
'name':
self.datastructure.face_name(fkey),
'color':
colordict[fkey],
'layer':
self.datastructure.face_attribute(fkey, 'layer', None)
})
guids = compas_rhino.draw_faces(faces,
layer=self.layer,
clear=False,
redraw=False)
if not join_faces:
return guids
guid = rs.JoinMeshes(guids, delete_input=True)
rs.ObjectLayer(guid, self.layer)
rs.ObjectName(guid, '{}.mesh'.format(self.datastructure.name))
if color:
rs.ObjectColor(guid, color)
return guid
def construct_mesh_step(points):
meshes = []
### step
for i in xrange(1, len(points) - 1):
vertex_ = [(0, int(i), int(i) + 1, int(i) + 1)]
m = rs.AddMesh(points, vertex_)
meshes.append(m)
mesh_joined = rs.JoinMeshes(meshes)
return mesh_joined
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 meshExtrudePtsByVect(pts,vect,colorRow=None):
extrudeVect=vect
#rs.AddPoints(pts)
meshes=[]
#verts=[]
#faces=[]
for i in range(0,len(pts)-1):
p1=pts[i]
p2=pts[i+1]
p1up=p1+extrudeVect
p2up=p2+extrudeVect
m=addMeshQuad([p1,p1up,p2up,p2])
if colorRow is not None:
# rs.ObjectColor(m,colorRow[i])
rs.MeshVertexColors(m,[colorRow[i],colorRow[i],colorRow[i],colorRow[i]])
meshes.append(m)
mesh=rs.JoinMeshes(meshes,True)
return mesh
def meshExtrudeCrvToPattern(crv, facadeType, totalHeightVect):
crv = rs.CopyObject(crv)
global TYPECOLORS
totalLength = rs.VectorLength(totalHeightVect)
restLength = totalLength
length = facadeType.heights[0]
counter = 0
meshes = []
def genRow(crv, length, facadeType, counter):
patterIndex = counter % len(facadeType.pattern)
extrudeVect = Rhino.Geometry.Vector3d(0, 0, length)
pts = divCrvByLengths(crv, facadeType.widths)
colorRow = genMeshColorRow(pts, facadeType.pattern[patterIndex],
TYPECOLORS)
m = meshExtrudePtsByVect(pts, extrudeVect, colorRow)
return m
if length > 0:
while restLength - length > 0:
m = genRow(crv, length, facadeType, counter)
meshes.append(m)
#prepare for next round
counter += 1
restLength -= length
if counter > 20: break
crv = rs.MoveObject(crv, Rhino.Geometry.Vector3d(0, 0, length))
length = facadeType.heights[counter % len(facadeType.heights)]
#print('length:',length)
#print('rest length:',restLength)
if length == -1: break
if restLength > 0:
finalLength = restLength
#print('final length:',finalLength)
m = genRow(crv, finalLength, facadeType, counter)
meshes.append(m)
rs.DeleteObject(crv)
return rs.JoinMeshes(meshes, True)
def divSrfsToMesh(srfs,width=1500,extrudeVect=None):
meshes=[]
for s in srfs:
if not rs.IsSurface(s):continue
top,bot,verts=getSrfTopBotVertCrvs(s)
if extrudeVect is None:
p1=rs.CurveStartPoint(verts[0])
p2=rs.CurveEndPoint(verts[0])
if p1[2]>p2[2]: extrudeVect=p1-p2
else: extrudeVect=p2-p1
if bot is None:
continue
pts=rs.DivideCurve(bot,round(rs.CurveLength(bot)/width))
meshes.append(meshExtrudePtsByVect(pts,extrudeVect))
rs.DeleteObjects([top,bot])
rs.DeleteObjects(verts)
mesh=rs.JoinMeshes(meshes,True)
return mesh
import rhinoscriptsyntax as rs
import Rhino
import scriptcontext as sc
for l in rs.LayerNames():
rs.CurrentLayer(l)
print(l)
meshes = rs.ObjectsByLayer(l)
print(meshes)
meshes = rs.JoinMeshes(meshes, True)
rs.SplitDisjointMesh(meshes, True)
def mesh_draw_faces(mesh,
keys=None,
color=None,
layer=None,
clear_layer=False,
clear_faces=False,
redraw=True,
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.
color : str, tuple, dict (None)
The color specififcation for the faces.
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 faces, provide a single color specification.
Individual colors can be assigned using a dictionary of key-color pairs.
Missing keys will be assigned the default face color (``self.defaults['face.color']``).
Default is to use the color of the parent layer.
layer : str (None)
The layer in which the edges are drawn.
Default is to draw in the current layer.
clear_layer : bool (False)
Clear the drawing layer.
redraw : bool (True)
Redraw the view after adding the edges.
join_faces : bool (False)
Join the faces into a polymesh object.
Notes
-----
The faces are named using the following template:
``"{}.face.{}".format(self.mesh.attributes['name'], key)``.
This name is used afterwards to identify faces of the mesh in the Rhino model.
Examples
--------
>>>
"""
artist = MeshArtist(mesh)
artist.layer = layer
if clear_layer:
artist.clear_layer()
if clear_faces:
artist.clear_faces()
guids = artist.draw_faces(color=color)
if redraw:
artist.redraw()
if join_faces:
guid = rs.JoinMeshes(guids, delete_input=True)
return guid
return guids
import rhinoscriptsyntax as rs
if __name__ == '__main__':
poly_srf = rs.GetObjects("Select Objects", 8 + 16)
if poly_srf:
srfs_explo = rs.ExplodePolysurfaces(poly_srf)
if srfs_explo:
srfs = srfs_explo
else:
srfs = poly_srf
trg_len_min = 1
trg_len_max = 2.8
dummy = rs.GetReal("Maximum distance to surface", 0.05)
rhino_meshes = []
for i, srf in enumerate(srfs):
print("Computing Surface {0} of {1}".format(i + 1, len(srfs) + 1))
rs.EnableRedraw(False)
rs.HideObject(srf)
rhino_meshes.append(
nurbs_to_mesh_ani(srf, trg_len_min, trg_len_max, vis=1))
if srfs_explo:
rs.DeleteObject(srf)
#rs.ShowObjects(srfs)
rs.JoinMeshes(rhino_meshes, True)
pointsToSurface(masterList[i], masterList[x], resultingSurfaces)
for i in range(len(rMasterList)):
x = i + 1
if x >= len(rMasterList):
print "Done Two"
break
else:
pointsToSurface(rMasterList[i], rMasterList[x], rResultingSurfaces)
for i in range(len(sMasterList)):
x = i + 1
if x >= len(sMasterList):
print "Done Three"
break
else:
pointsToSurface(sMasterList[i], sMasterList[x], sResultingSurfaces)
rSurfaces = resultingSurfaces + rResultingSurfaces + sResultingSurfaces
rs.SelectObjects(rSurfaces)
rs.Command("_Mesh")
rs.Command("_Delete")
rs.Command("_SelDup")
rs.Command("_Delete")
rs.EnableRedraw(True)
rMeshes = rs.GetObjects("Select resulting meshes", 32)
finalMesh = rs.JoinMeshes(rMeshes, True)
