![\"\"](\"http:\/\/www.new-territories.com\/blog\/ncertainties\/col12\/wp-content\/uploads\/2012\/12\/draw.png\" "\\"draw\\"")
<\/a><\/p>\n<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
FREI OTTO<\/p>\n
SUBDIVIDE MESH TO ATTRACTORS<\/p>\n
<\/p>\n
import rhinoscriptsyntax as rs<\/p>\n
“””
\nScript written by Ezio Blasetti
\nScript copyrighted by algorithmicdesign.net
\nScript version Sunday, June 25, 2011 1:07:59 PM
\n###########################################################################################
\nThis is a simple recursive subdivision example with use of python classes.
\nIt takes as an input a single mesh, the recursive limmit & a scale for the recursive vector
\n“””<\/p>\n
def averagePts(pts):
\nav = [0,0,0]
\nfor pt in pts:
\nav = rs.PointAdd(av,pt)
\nav = rs.VectorScale(av, 1\/(len(pts)))
\nreturn rs.PointAdd(av,[0,0,0])<\/p>\n
def normalizeAverageDistanceFactor2Attractors(pts, attrs):
\nlistReturn = []
\nallAvDist = []
\nminAvDist = 5000000000
\nmaxAvDist = -1
\nfor pt in pts:
\nsumDist = 0
\nfor attr in attrs:
\nsumDist += rs.Distance(pt, attr)
\navDist = sumDist \/ len(attrs)
\nallAvDist.append(avDist)
\nif avDist < minAvDist : minAvDist = avDist
\nif avDist > maxAvDist : maxAvDist = avDist
\nfor i in range(len(pts)):
\nlistReturn.append( (allAvDist[i] – minAvDist)\/(maxAvDist – minAvDist) )
\nreturn listReturn<\/p>\n
def intAverageDistanceFactor2Attractors(pts, attrs, max):
\nlistReturn = []
\nallAvDist = []
\nminAvDist = 5000000000
\nmaxAvDist = -1
\nfor pt in pts:
\nsumDist = 0
\nfor attr in attrs:
\nsumDist += rs.Distance(pt, attr)
\navDist = sumDist \/ len(attrs)
\nallAvDist.append(avDist)
\nif avDist < minAvDist : minAvDist = avDist
\nif avDist > maxAvDist : maxAvDist = avDist
\nfor i in range(len(pts)):
\nlistReturn.append( max – int( ((allAvDist[i] – minAvDist)\/(maxAvDist – minAvDist))*(max+1)) )
\nreturn listReturn<\/p>\n
class sierpinski():
\ndef __init__(self, seedMeshGUID, ATTRS, MAX):
\n#here we initiate the class by matching the inputs to the variables in the class
\nself.id = seedMeshGUID
\nself.max = MAX
\n#here we make sure that the mesh is made only of triangles
\nif rs.MeshQuadCount(self.id)>0:
\nrs.MeshQuadsToTriangles(self.id)
\n#here we store other information we’ll need later into a few more variables
\nself.vtxs = rs.MeshVertices(self.id)
\nself.fVtxs = rs.MeshFaceVertices(self.id)
\nself.normals = rs.MeshFaceNormals(self.id)
\ncenters = rs.MeshFaceCenters(self.id)
\nself.faceRecursionCount = intAverageDistanceFactor2Attractors(centers, ATTRS, MAX)
\nself.newVtxs = self.vtxs[:]<\/p>\n
def subdivideFace(self, faceIndex):
\n“””
\nthis function returns a new mesh -pyramid- for a given faceIndex of a mesh
\n“””
\n#here we initiate two new lists to contain the vertices and faceVertices of the pyramid
\n#newMeshVTXs = []
\nnewMeshFaceVTXs = []
\n#################################################
\nfaceToSubdivide = self.fVtxs[faceIndex]
\n#here we call a custom function to calculate the new vertex from the centroid
\n#centroidPt = self.newPoint4Subd(faceIndex, scale)
\npt01 = averagePts([self.vtxs[faceToSubdivide[0]], self.vtxs[faceToSubdivide[1]]])
\npt12 = averagePts([self.vtxs[faceToSubdivide[1]], self.vtxs[faceToSubdivide[2]]])
\npt20 = averagePts([self.vtxs[faceToSubdivide[2]], self.vtxs[faceToSubdivide[0]]])
\n#we append in the vertex list the vertices of the parent face
\n#self.newVtxs.append(self.vtxs[faceToSubdivide[0]])
\n#self.newVtxs.append(self.vtxs[faceToSubdivide[1]])
\n#self.newVtxs.append(self.vtxs[faceToSubdivide[2]])
\n#and the newly calculated centroid
\nself.newVtxs.append(pt01)
\nself.newVtxs.append(pt12)
\nself.newVtxs.append(pt20)
\n#here we append the faceVertices of the new pyramid
\n#self.fVtxs.pop(faceIndex)
\nnewMeshFaceVTXs.append((faceToSubdivide[0],len(self.newVtxs)-3\u00a0 ,len(self.newVtxs)-1))
\nnewMeshFaceVTXs.append((len(self.newVtxs)-3\u00a0 ,faceToSubdivide[1],len(self.newVtxs)-2))
\nnewMeshFaceVTXs.append((len(self.newVtxs)-1\u00a0 ,len(self.newVtxs)-2\u00a0 ,faceToSubdivide[2]))
\nnewMeshFaceVTXs.append((len(self.newVtxs)-3\u00a0 ,len(self.newVtxs)-2\u00a0 ,len(self.newVtxs)-1))
\n#we make the new mesh -pyramid- and return its GUID
\nreturn newMeshFaceVTXs<\/p>\n
def subdivide(self):
\n“””
\nthis function will loop through all the faces of the mesh and subdivide them
\n“””
\nfor j in range(self.max):
\nfaceCount = len(self.fVtxs)
\nrs.EnableRedraw(False)
\n#flip = 1
\nnewFaceVtxs = []
\nnewFaceRecCount = []
\nfor i in range(faceCount):
\n#scale = scale*flip
\n#this is where we make the new pyramids for each face
\ncurrentRec = self.faceRecursionCount[i]
\nif self.faceRecursionCount[i]>j:
\nr = self.subdivideFace(i)
\nfor i in range(len(r)):
\nnewFaceRecCount.append(currentRec-1)
\nnewFaceVtxs.extend(r)
\nelse:
\nnewFaceVtxs.append(self.fVtxs[i])
\nnewFaceRecCount.append(currentRec-1)<\/p>\n
#flip = flip*(-1)
\n#this is where we join all the pyramids in one mesh
\n#self.joinChildren()
\nrs.DeleteObject(self.id)
\nself.id = rs.AddMesh(self.newVtxs,newFaceVtxs)
\nrs.EnableRedraw(True)
\n#here we update the information of vtxs,faces,normals in the class variables
\nself.vtxs = rs.MeshVertices(self.id)
\nself.fVtxs = rs.MeshFaceVertices(self.id)
\nself.normals = rs.MeshFaceNormals(self.id)
\nself.newVtxs = self.vtxs[:]
\nself.faceRecursionCount = newFaceRecCount<\/p>\n
def joinChildren(self):
\n“””
\nthis function will join all the meshes in the self.childrenIDs:
\nwhich means it will create a new mesh whih contains all the vertices and faces
\nof those meshes and delete the old ones. This function basically calculates (sorts out) the two lists
\nrequired to make a mesh, namely the mesh vertices and the mesh faceVertices.
\nExample:
\nmesh0VTXs\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 = [[0,0,0],[1,0,0],[0,1,0],[0,0,1]]
\nmesh0FaceVTXs\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 = [[3,0,1],[3,1,2],[3,2,0]]
\nmesh1VTXs\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 = [[0,0,0],[-1,0,0],[0,1,0],[0,0,-1]]
\nmesh1FaceVTXs\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 = [[3,0,1],[3,1,2],[3,2,0]]
\nResult:
\nmesh0and1VTXs\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 = [[0,0,0],[1,0,0],[0,1,0],[0,0,1],[0,0,0],[-1,0,0],[0,1,0],[0,0,-1]]
\nmesh0and1FaceVTXs\u00a0\u00a0 = [[3, 0, 1],[3, 1, 2],[3, 2, 0],[7, 0, 5],[7, 5, 2],[7, 2, 0]]
\n“””
\n#here we initiate two new lists to contain the vertices and faceVertices of the new ‘sum’ mesh
\nnewMeshVTXs = []
\nnewMeshFaceVTXs = []
\narrayOfMeshes = self.childrenIDs
\n#for every mesh in the array of meshes to join
\nfor currentMesh in arrayOfMeshes:
\n#we store its vertices in a list
\nmeshVTXs = rs.MeshVertices(currentMesh)
\n#and extend the list of the new vertices by adding all of these vertices inside
\nnewMeshVTXs.extend(meshVTXs)
\n#we store the faceVertices of the current mesh in a list
\nmeshFaceVTXs = rs.MeshFaceVertices(currentMesh)
\n#we loop through each face in faceVertices list
\nfor face in meshFaceVTXs:
\n#start a new list for the adjusted face
\nnewFace = []
\n#loop through each index (vertex) in the current face
\nfor index in face:
\n#find the right index for the current vertex and append it in the newFace list
\nnewFace.append(newMeshVTXs.index(meshVTXs[index]))
\n#append the newFace in the list of new faces
\nnewMeshFaceVTXs.append(newFace)
\n#delete the old meshes
\nrs.DeleteObjects(arrayOfMeshes)
\n#restart the children list
\nself.childrenIDs = []
\n#delete the parent mesh
\nrs.DeleteObject(self.id)
\n#add the new mesh – joined children
\nself.id = rs.AddMesh(newMeshVTXs, newMeshFaceVTXs)
\n#return true since everything went good
\nreturn True<\/p>\n
def main():
\nmesh = rs.GetObject(“select the mesh to subdivive”,rs.filter.mesh)
\nmax = rs.GetInteger(“Enter the number of maximum recursion: “, 4, 1, 8)
\nstrAttrs = rs.GetObjects(“select some attractors”,rs.filter.point)
\nattrs = []
\nfor str in strAttrs:
\nattrs.append(rs.PointCoordinates(str))
\n###################################################################
\nmySierpinski = sierpinski(mesh, attrs, max)
\n###################################################################
\nmySierpinski.subdivide()<\/p>\n
main()<\/p>\n
<\/p>\n
DRAW LINES ON MESH<\/p>\n