def replace(self, mesh):
newMesh = Mesh()
newNodes = []
for n in mesh.points:
normal = n.getNormal()
normal.setMag(self.offset)
node = Node(n)
node.add(normal)
newNodes.append(node)
for oldFace in mesh.faces:
newFace = Face()
for node in oldFace.points:
newFace.addPoint(newNodes[node.id])
newFace.inverse()
newMesh.addFace(newFace)
newMesh.addFace(oldFace)
if self.closeSides == True:
for face in mesh.faces:
edges = face.getEdges()
for e in edges:
if e.f1 == None or e.f2 == None:
newMesh.addFace(e.n2, e.n1, newNodes[e.n1.id],
newNodes[e.n2.id])
newMesh.constructTopology()
return newMesh
def getNodePt(self, n):
nbFaces = n.getFaces()
sumFaces = PVector()
for face in nbFaces:
sumFaces.add(face.getCenterAverage())
sumFaces.div(nbFaces.size())
sumEdges = PVector()
for edge in n.edges:
sumEdges.add(edge.getCenter())
sumEdges.mult(2.0 / n.getNumEdges())
sumPos = PVector(n.x, n.y, n.z)
sumPos.mult(n.getNumEdges() - 3)
newPos = PVector()
newPos.add(sumFaces)
newPos.add(sumEdges)
newPos.add(sumPos)
newPos.div(n.getNumEdges())
#normal = n.getNormal()
#normal.mult(getNodeExtrude(n) * extrudeFactorNode)
#newPos.add(normal);
node = Node(newPos)
node.comment = n.comment
return node
def getEdgePt(self, edge):
node = Node(edge.getCenter())
dX = edge.n2.x - edge.n1.x
dY = edge.n2.y - edge.n1.y
dZ = edge.n2.z - edge.n1.z
if dZ > dX and dZ > dY:
normal = edge.getNormal()
normal.mult(self.factorEdge)
node.add(normal)
return node
def replace(self, meshIn):
newMesh = Mesh()
for face in meshIn.faces:
taperFace = face
for j in range(self.iterations):
normal = taperFace.getNormal()
center = taperFace.getCenterAverage()
normal.mult(self.extrude)
rV = PVector(
random(-self.extrude * self.rnd, self.extrude * self.rnd))
normal.add(rV)
normal.setMag(self.extrude)
#center.add(normal)
newNodes = []
for node in taperFace.points:
dir = PVector.sub(center, node)
dir.mult(self.offset)
dir.add(node)
dir.add(normal)
newNodes.append(Node(dir))
for i in range(taperFace.getNumPoints()):
n1 = taperFace.getPoint(i)
n2 = taperFace.getPoint((i + 1) % taperFace.getNumPoints())
n3 = newNodes[(i + 1) % taperFace.getNumPoints()]
n4 = newNodes[(i) % taperFace.getNumPoints()]
newFace = newMesh.addFace(n1, n2, n3, n4)
newFace.inheritPropertiesFrom(face)
taperFace = Face(newNodes)
if self.close:
newFace = newMesh.addFace(taperFace)
newFace.inheritPropertiesFrom(face)
newMesh.constructTopology()
return newMesh
def replace(self, oldMesh):
# clone the old mesh
# oldMesh.getCopy()
bounds = oldMesh.getBounds()
newMesh = Mesh()
newNodes = [None] * oldMesh.points.size()
for node in oldMesh.points:
newNodes[node.id] = Node(node)
for face in oldMesh.faces:
newFace = Face()
newMesh.addFace(newFace)
for node in face.points:
newFace.points.add(newNodes[node.id])
newMesh.constructTopology()
# make a backup of the normals, not necessary if this is a copy of new mesh
normalBackup = [None] * newMesh.points.size()
for node in newMesh.points:
normalBackup[node.id] = node.getNormal()
# shift the nodes
for node in newMesh.points:
#nml=normalBackup[node.id]
nml = oldMesh.getPoint(node.id).getNormal()
translateMap = 30 * sin(map(node.y, bounds.y1, bounds.y2, 0, 30))
nml.mult(translateMap)
node.add(nml)
return newMesh
def getFacePt(self,face):
weightedCenter=PVector()
totalWeight=0.0
for i, node in enumerate(face.points):
p=PVector(node.x,node.y,node.z)
p.mult(self.weights[i])
weightedCenter.add(p)
totalWeight=self.weights[i]+totalWeight
if totalWeight==0:
totalWeight=1
weightedCenter.div(totalWeight)
return Node(weightedCenter)
def replace(self,meshIn):
newMesh = Mesh()
for face in meshIn.faces:
normal = face.getNormal()
normal.mult(self.extrude)
center = face.getCenterAverage()
center.add(normal)
centerNode = Node(center)
for ii in range(face.getNumPoints()):
n1 = face.getPoint(ii)
n2 = face.getPoint((ii + 1) % face.getNumPoints())
newFace = newMesh.addFace(n1, n2, centerNode)
newFace.inheritPropertiesFrom(face)
newMesh.constructTopology()
return newMesh
def getEdgePt(self, edge):
vSum = PVector()
vSum.add(edge.n1)
vSum.add(edge.n2)
nFace = 0
if (edge.f1 != None):
nFace += 1
vSum.add(edge.f1.getCenterAverage())
if (edge.f2 != None):
nFace += 1
vSum.add(edge.f2.getCenterAverage())
vSum.div(nFace + 2)
#normal = edge.getNormal()
#normal.mult(getEdgeExtrude(edge) * extrudeFactorEdge);
#vSum.add(normal)
return Node(vSum)
def getEdgePt(self,edge):
node =Node(edge.getCenter())
dX=abs(edge.n2.x-edge.n1.x)
dY=abs(edge.n2.y-edge.n1.y)
dZ=abs(edge.n2.z-edge.n1.z)
if dX>dY and dX >dZ:
normal=edge.getNormal()
normal.mult(self.factorEdge)
node.add(normal)
else:
e=PVector(dX,dY,dZ)
e.normalize()
normal=edge.getNormal()
cross = normal.cross(e)
cross.mult(self.factorEdge)
node.add(cross)
return node
def getFacePt(self, face):
node = Node(face.getCenterAverage())
#normal = face.getNormal()
#normal.mult(extrudeFactorFace);
#node.add(normal)
return node
def getFacePt(self, face):
node = Node(face.getCenterAverage())
normal = face.getNormal()
normal.mult(self.factorFace)
node.add(normal)
return node
def getEdgePt(self, edge):
return Node(edge.getCenter())
def getFacePt(self, face):
return Node(face.getCenterAverage())
def getNodePt(self, n):
return Node(n)
def getNodePt(self, oldNode):
return Node(oldNode)
