def replace(self, oldMesh):
# collectNodes
faceNodes = [None] * oldMesh.faces.size()
edgeNodes = [None] * oldMesh.edges.size()
nodeNodes = [None] * oldMesh.points.size()
for face in oldMesh.faces:
faceNodes[face.id] = self.getFacePt(face)
for edge in oldMesh.edges:
edgeNodes[edge.id] = self.getEdgePt(edge)
for node in oldMesh.points:
nodeNodes[node.id] = self.getNodePt(node)
# compose
newMesh = Mesh()
for face in oldMesh.faces:
for ii in range(face.getNumPoints()):
n1 = face.getPoint(ii)
n2 = face.getPoint((ii + 1) % face.getNumPoints())
n3 = face.getPoint((ii + 2) % face.getNumPoints())
e1 = n1.getEdge(n2)
e2 = n2.getEdge(n3)
newNodes = [None] * 4
newNodes[0] = edgeNodes[e1.id]
newNodes[1] = nodeNodes[n2.id]
newNodes[2] = edgeNodes[e2.id]
newNodes[3] = faceNodes[face.id]
newFace = newMesh.addFace(newNodes)
newFace.inheritPropertiesFrom(face)
newMesh.constructTopology()
return newMesh
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 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 replace(self, mesh):
newMesh = Mesh()
for face in mesh.faces:
if face.group == typePlotLowrise:
if random(1) < self.splits:
extruded = FaceRules.extrude(
face,
randint(int(self.minExtrude / 3),
int(self.maxExtrude / 3)) * 3)
splitted = FaceRules.splitRel(
extruded[4], randint(0, 1),
random(self.minSplit, self.maxSplit))
extrudedSec = FaceRules.extrude(
splitted[0], PVector(0, 0,
randint(0, 2) * 3))
extruded.remove(extruded[4])
splitted.remove(splitted[0])
for i, element in enumerate(extruded):
if i != 4:
if random(1) > 0.5:
element.group = typeFacade1
else:
element.group = typeFacade2
#splitted[0].group = typeTerrace
for i, element in enumerate(extrudedSec):
if i == 4:
element.group = typeRoof
elif random(1) > 0.5:
element.group = typeFacade1
else:
element.group = typeFacade2
newFaces = extruded
newFaces.extend(splitted)
newFaces.extend(extrudedSec)
else:
extruded = FaceRules.extrude(
face,
randint(int(self.minExtrude / 3),
int(self.maxExtrude / 3)) * 3)
for i, element in enumerate(extruded):
if i == 4:
element.group = typeRoof
elif random(1) > 0.5:
element.group = typeFacade1
else:
element.group = typeFacade2
newFaces = extruded
for cFace in newFaces:
newMesh.addFace(cFace)
else:
newMesh.addFace(face)
newMesh.constructTopology()
return newMesh
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 replace(self, mesh):
newMesh=Mesh()
for face in mesh.faces:
extrusion = self.factorExtrude
if random(1) > 0.5:
extrusion = self.factorExtrude2
newFaces=FaceRules.extrudeToPoint(face, extrusion)
for cFace in newFaces:
newMesh.addFace(cFace)
newMesh.constructTopology()
return newMesh
def replace(self, oldMesh):
newMesh=Mesh()
for face in oldMesh.faces:
newFaces=FaceRules.extrudeToPoint(face, self.factorExtrude)
counter=0
for cFace in newFaces:
cFace.group=counter
newMesh.addFace(cFace)
counter+=1
newMesh.constructTopology()
return newMesh
def replace(self, oldMesh):
newMesh = Mesh()
for face in oldMesh.faces:
extrusion = self.factorExtrude
if random(1) > 0.5:
extrusion = self.factorExtrude2
newFaces = FaceRules.extrudeToPoint(
face, extrusion) # creating new faces
for cFace in newFaces:
newMesh.addFace(cFace) #storing new face into new mesh
newMesh.constructTopology()
return newMesh
def replace(self, mesh):
newMesh=Mesh()
for face in mesh.faces:
if face.group==typeBlock: #if is block then
indicator=random(1)
#CREATE PARKS
if indicator<=0.1: #create simple empty plot
face.group = typePlotEmpty1 #Empty, park
newMesh.addFace(face)
#CREATE RESIDENTIAL AREAS
elif 0.15 < indicator <=0.7:
newFaces=FaceRules.splitGrid(face, 3, int(random(4, self.f2)))
for f in newFaces:
r= random(1)
if r<0.2:
f.group = typePlotEmpty1 #empty
elif r > 0.9: #high
f.group = typePlotHighrise1
else:
f.group = typePlotLowrise #low
newMesh.addFace(f)
#CREATE LANDMARKS
else:
#newFaces=FaceRules.splitAbs(face, 0, random(5,self.f1))
newFaces=FaceRules.splitRel(face, 0, random(0.3,self.f1))
newFaces[0].group = typePlotEmpty2 #Empty, plaza
newFaces[1].group = typePlotHighrise2 #HighRize, Landmark
for cFace in newFaces:
newMesh.addFace(cFace)
else:
newMesh.addFace(face)
newMesh.constructTopology()
return newMesh
def replace(self, mesh):
newMesh=Mesh()
for face in mesh.faces:
if face.group == typeFacade2:
#newFaces=FaceRules.splitOffset(face,self.factorOffset)
#counter=0
#for i,sFace in enumerate(newFaces):
#sFace.group=counter
#newMesh.addFace(cFace)
# if i==4:
#offsetFaces = FaceRules.splitOffset(face,self.factorOffset)
splitFaces = FaceRules.splitRel(face, 1 ,self.factorProportion)
newsplitFaces=FaceRules.splitRel(splitFaces[1], randint(0,1) ,self.factorProportion)
#for snewFace in newsplitFaces:
# newExList.addFace(snewFace(1))
# for exFaces in newExList:
# newExFaces = FaceRules.extrude(exFaces,30)
#newMesh.addFace(snewFace)
newExFaces1 = FaceRules.extrude(newsplitFaces[1],self.factorExtrude1)
newExFaces2 = FaceRules.extrude(newsplitFaces[0],self.factorExtrude)
newMesh.addFace(splitFaces[0])
newExFaces1[4].group = typeFacade1
newExFaces2[4].group = typeFacade1
for exFace in newExFaces1:
newMesh.addFace(exFace)
for exFace in newExFaces2:
newMesh.addFace(exFace)
# else:
#newMesh.addFace(sFace)
#counter+=1
else:
newMesh.addFace(face)
newMesh.constructTopology()
return newMesh
def replace(self, mesh):
newMeshes = []
newMesh = Mesh()
newMesh2 = Mesh()
for face in mesh.faces:
if face.group == typePlotEmpty1:
self.h = random(4, 7)
offsetX = random(-3, 3)
offsetY = random(-3, 3)
center = face.getCenterAverage()
sphereHD = primitives.Sphere(center.x + offsetX,
center.y + offsetY, self.h,
self.h / 2)
sph = sphereHD.getMesh()
boxHD = primitives.Box(center.x + offsetX - self.h / 24,
center.y + offsetY - self.h / 24, 0,
center.x + offsetX + self.h / 24,
center.y + offsetY + self.h / 24,
self.h)
bx = boxHD.getMesh()
for tree in sph.faces:
newMesh.addFace(tree)
for trunk in bx.faces:
newMesh2.addFace(trunk)
newMeshes.append(newMesh)
newMeshes.append(newMesh2)
newMesh = Mesh()
newMesh2 = Mesh()
if face.getArea() > 150:
inner = FaceRules.splitOffset(face, 4)
center = face.getCenterAverage()
for node in inner[4].points:
sphereHD = primitives.Sphere(node.x, node.y, self.h,
self.h / 2)
sph = sphereHD.getMesh()
boxHD = primitives.Box(node.x - self.h / 24,
node.y - self.h / 24, 0,
node.x + self.h / 24,
node.y + self.h / 24, self.h)
bx = boxHD.getMesh()
for tree in sph.faces:
newMesh.addFace(tree)
for trunk in bx.faces:
newMesh2.addFace(trunk)
newMeshes.append(newMesh)
newMeshes.append(newMesh2)
newMesh = Mesh()
newMesh2 = Mesh()
if face.getArea() > 500:
minX = 10000
maxX = 0
minY = 10000
maxY = 0
minZ = 10000
maxZ = 0
for node in face.points:
if node.x < minX:
minX = node.x
if node.y < minY:
minY = node.y
if node.z < minZ:
minZ = node.z
if node.x > maxX:
minX = node.x
if node.y > maxY:
minY = node.y
if node.z > maxZ:
minZ = node.z
for i in range(int(face.getArea() / 20)):
loc = PVector(random(minX + 4, maxX - 4),
random(minY + 4, maxY - 4),
random(minZ, maxZ))
sphereHD = primitives.Sphere(loc.x, loc.y, self.h,
self.h / 2)
sph = sphereHD.getMesh()
boxHD = primitives.Box(loc.x - self.h / 24,
loc.y - self.h / 24, 0,
loc.x + self.h / 24,
loc.y + self.h / 24, self.h)
bx = boxHD.getMesh()
for tree in sph.faces:
newMesh.addFace(tree)
for trunk in bx.faces:
newMesh2.addFace(trunk)
newMeshes.append(newMesh)
newMeshes.append(newMesh2)
newMesh = Mesh()
newMesh2 = Mesh()
minX = 10000
maxX = 0
minY = 10000
maxY = 0
minZ = 10000
maxZ = 0
if face.group == typePlotEmpty2:
self.h = random(4, 7)
offsetX = random(-3, 3)
offsetY = random(-3, 3)
center = face.getCenterAverage()
sphereHD = primitives.Sphere(center.x + offsetX,
center.y + offsetY, self.h,
self.h / 2)
sph = sphereHD.getMesh()
boxHD = primitives.Box(center.x + offsetX - self.h / 24,
center.y + offsetY - self.h / 24, 0,
center.x + offsetX + self.h / 24,
center.y + offsetY + self.h / 24,
self.h)
bx = boxHD.getMesh()
for tree in sph.faces:
newMesh.addFace(tree)
for trunk in bx.faces:
newMesh2.addFace(trunk)
newMeshes.append(newMesh)
newMeshes.append(newMesh2)
newMesh = Mesh()
newMesh2 = Mesh()
if face.getArea() > 150:
inner = FaceRules.splitOffset(face, -4)
center = face.getCenterAverage()
for node in inner[4].points:
sphereHD = primitives.Sphere(node.x, node.y, self.h,
self.h / 2)
sph = sphereHD.getMesh()
boxHD = primitives.Box(node.x - self.h / 24,
node.y - self.h / 24, 0,
node.x + self.h / 24,
node.y + self.h / 24, self.h)
bx = boxHD.getMesh()
for tree in sph.faces:
newMesh.addFace(tree)
for trunk in bx.faces:
newMesh2.addFace(trunk)
newMeshes.append(newMesh)
newMeshes.append(newMesh2)
newMesh = Mesh()
newMesh2 = Mesh()
if face.getArea() > 500:
minX = 10000
maxX = 0
minY = 10000
maxY = 0
minZ = 10000
maxZ = 0
for node in face.points:
if node.x < minX:
minX = node.x
if node.y < minY:
minY = node.y
if node.z < minZ:
minZ = node.z
if node.x > maxX:
minX = node.x
if node.y > maxY:
minY = node.y
if node.z > maxZ:
minZ = node.z
for i in range(int(face.getArea() / 20)):
loc = PVector(random(minX + 4, maxX - 4),
random(minY + 4, maxY - 4),
random(minZ, maxZ))
sphereHD = primitives.Sphere(loc.x, loc.y, self.h,
self.h / 2)
sph = sphereHD.getMesh()
boxHD = primitives.Box(loc.x - self.h / 24,
loc.y - self.h / 24, 0,
loc.x + self.h / 24,
loc.y + self.h / 24, self.h)
bx = boxHD.getMesh()
for tree in sph.faces:
newMesh.addFace(tree)
for trunk in bx.faces:
newMesh2.addFace(trunk)
newMeshes.append(newMesh)
newMeshes.append(newMesh2)
newMesh = Mesh()
newMesh2 = Mesh()
minX = 10000
maxX = 0
minY = 10000
maxY = 0
minZ = 10000
maxZ = 0
for meshT in newMeshes:
mesh.addMeshFacesNodes(meshT)
return mesh
def replace(self, mesh):
newMesh = Mesh()
for face in mesh.faces:
if face.group == typeRoof:
counter = 0
if face.getArea() > 300000:
newtFaces = FaceRules.splitGrid(face, 20, 30)
for t in newtFaces:
if random(1) > 0.5:
faces = FaceRules.extrude(t, self.factorExtrude)
for f in faces:
newMesh.addFace(f)
else:
newMesh.addFace(t)
elif face.getArea() <= 300000 and face.getArea() > 200000:
newFaces = FaceRules.extrudeToPointTapered(
face, self.factorExtrude, self.factorExtrude / 3)
for cFace in newFaces:
cFace.group = counter
newMesh.addFace(cFace)
elif face.getArea() <= 100000 and face.getArea() > 50000:
newFaces = FaceRules.extrudeToPoint(
face, self.factorExtrude2)
for cFace in newFaces:
cFace.group = counter
newMesh.addFace(cFace)
else:
newFaces = FaceRules.roof(face, self.factorExtrude)
for cFace in newFaces:
cFace.group = counter
newMesh.addFace(cFace)
else:
newMesh.addFace(face)
newMesh.constructTopology()
return newMesh
def replace(self, inputmesh):
newMesh = Mesh()
## subdivide land ##
for face in inputmesh.faces:
sdf = int(self.subdivFactor)
sdFaces = FaceRules.splitGrid(face, sdf, 2)
## subdivide street and lot ##
for cFace in sdFaces:
std = 0 - self.streetDist
streetFaces = FaceRules.splitOffset(cFace, std)
for i, stf in enumerate(streetFaces):
## lot ##
if i == 4:
spd = self.splitDist
splitFaces = FaceRules.splitAbs(stf, 0, spd)
for i, spf in enumerate(splitFaces):
## hedge ##
if i == 0:
hedgeFaces = FaceRules.extrude(spf, 1.2)
for hedge in hedgeFaces:
newMesh.addFace(hedge)
else:
swd = self.sidewalkDist
lotFaces = FaceRules.splitOffset(spf, swd)
for i, lf in enumerate(lotFaces):
## block ##
if i == 4:
lf.group = typeBlock
newMesh.addFace(lf)
#extrudeBlock = FaceRules.extrude(lf, 0)
#for extrusion in extrudeBlock:
# newMesh.addFace(extrusion)
## sidewalk ##
else:
swFaces = FaceRules.extrude(lf, 0.2)
for swf in swFaces:
newMesh.addFace(swf)
## street ##
else:
streetFaces = FaceRules.extrude(stf, 0)
for stf in streetFaces:
newMesh.addFace(stf)
newMesh.constructTopology()
return newMesh
def replace(self, mesh):
newMeshes = []
newMesh = Mesh()
newMesh2 = Mesh()
for face in mesh.faces:
if face.group == typePlotEmpty:
self.h = random(4, 7)
offsetX = random(-3, 3)
offsetY = random(-3, 3)
center = face.getCenterAverage()
sphereHD = primitives.Sphere(center.x + offsetX,
center.y + offsetY, self.h,
self.h / 2)
sph = sphereHD.getMesh()
boxHD = primitives.Box(center.x + offsetX - self.h / 24,
center.y + offsetY - self.h / 24, 0,
center.x + offsetX + self.h / 24,
center.y + offsetY + self.h / 24,
self.h)
bx = boxHD.getMesh()
for tree in sph.faces:
newMesh.addFace(tree)
for trunk in bx.faces:
newMesh2.addFace(trunk)
newMeshes.append(newMesh)
newMeshes.append(newMesh2)
newMesh = Mesh()
newMesh2 = Mesh()
if face.getArea() > 70:
inner = FaceRules.splitOffset(face, 4)
center = face.getCenterAverage()
for node in inner[4].points:
sphereHD = primitives.Sphere(node.x, node.y, self.h,
self.h / 2)
sph = sphereHD.getMesh()
boxHD = primitives.Box(node.x - self.h / 24,
node.y - self.h / 24, 0,
node.x + self.h / 24,
node.y + self.h / 24, self.h)
bx = boxHD.getMesh()
for tree in sph.faces:
newMesh.addFace(tree)
for trunk in bx.faces:
newMesh2.addFace(trunk)
newMeshes.append(newMesh)
newMeshes.append(newMesh2)
newMesh = Mesh()
newMesh2 = Mesh()
for meshT in newMeshes:
mesh.addMeshFacesNodes(meshT)
return mesh
