def sd_sided_tapered(face, d=0.1):
# d should be between 0.01 and 0.49
bottom = vec.subtract(face.vertices[2], face.vertices[1])
top = vec.subtract(face.vertices[3], face.vertices[0])
b_vertices = []
b_vertices.append(face.vertices[1])
pv = vec.add(face.vertices[1], vec.scale(bottom, d))
b_vertices.append(pv)
pv = vec.add(face.vertices[1], vec.scale(bottom, 1-d))
b_vertices.append(pv)
b_vertices.append(face.vertices[2])
t_vertices = []
t_vertices.append(face.vertices[0])
pv = vec.add(face.vertices[0], vec.scale(top, d))
t_vertices.append(pv)
pv = vec.add(face.vertices[0], vec.scale(top, 1-d))
t_vertices.append(pv)
t_vertices.append(face.vertices[3])
newFaces = []
for i in range(3):
vts = []
vts.append(t_vertices[i])
vts.append(b_vertices[i])
vts.append(b_vertices[i+1])
vts.append(t_vertices[i+1])
newFaces.append(Face(vts))
return newFaces
def normalVertex2D(vprev, v, vnext):
vec1 = vec.subtract(v, vprev)
vec1 = vec.unitize(vec1)
vec2 = vec.subtract(vnext, v)
vec2 = vec.unitize(vec1)
n = vec.add(vec1, vec2)
n = vec.scale(n, 0.5)
t = n.x
n.x = -n.y
n.y = t
return n
def normalFromTriangle(v1,v2,v3):
"""
Returns the normal of a triangle defined by 3 vertices.
The normal is a vector of length 1 perpendicular to the plane of the triangle.
Arguments:
----------
v1, v2, v3 : mola.core.Vertex
the vertices get the normal from
"""
v = vec.subtract(v2, v1)
u = vec.subtract(v3, v1)
crossProduct=vec.cross(v, u)
return vec.unitize(crossProduct)
def _getVerticesBetween(v1,v2,n):
row = []
deltaV = vec.subtract(v2, v1)
deltaV = vec.divide(deltaV, n)
for i in range(n):
addV = vec.scale(deltaV, i)
row.append(vec.add(addV, v1))
row.append(v2)
return row
def shapeProfile(mesh):
zFunction = SinusFunction(zFreq, zAmp, zPhase, zOffset)
for v in mesh.vertices:
pos_z = (v.z/300.0)*2*math.pi
val_z = zFunction.getValue(pos_z)
normal = vec.subtract(v, Vertex(0, 0, v.z))
normal = vec.unitize(normal)
nvec = vec.scale(normal, val_z)
v.add(nvec)
return mesh
def extrudeTapered(face, height=0.0, fraction=0.5,doCap=True):
"""
Extrudes the face tapered like a window by creating an
offset face and quads between every original edge and the
corresponding new edge.
Arguments:
----------
face : mola.core.Face
The face to be extruded
height : float
The distance of the new face to the original face, default 0
fraction : float
The relative offset distance, 0: original vertex, 1: center point
default 0.5 (halfway)
"""
center_vertex = faceUtils.center(face)
normal = faceUtils.normal(face)
scaled_normal = vec.scale(normal, height)
# calculate new vertex positions
new_vertices = []
for i in range(len(face.vertices)):
n1 = face.vertices[i]
betw = vec.subtract(center_vertex, n1)
betw = vec.scale(betw, fraction)
nn = vec.add(n1, betw)
nn = vec.add(nn, scaled_normal)
new_vertices.append(nn)
new_faces = []
# create the quads along the edges
num = len(face.vertices)
for i in range(num):
n1 = face.vertices[i]
n2 = face.vertices[(i + 1) % num]
n3 = new_vertices[(i + 1) % num]
n4 = new_vertices[i]
new_face = Face([n1,n2,n3,n4])
new_faces.append(new_face)
# create the closing cap face
if doCap:
cap_face = Face(new_vertices)
new_faces.append(cap_face)
for new_face in new_faces:
faceUtils.copyProperties(face,new_face)
return new_faces
def normalEdge2D(vprev, v):
vec1 = vec.subtract(v, vprev)
vec1 = vec.unitize(vec1)
return vec.rot2D90(vec1)
def normalEdge2DNonUnified(vprev, v):
vec1 = vec.subtract(v, vprev)
return vec.rot2D90(vec1)
def normalFromTriangle(v1, v2, v3):
v = _vec.subtract(v2, v1)
u = _vec.subtract(v3, v1)
crossProduct = _vec.cross(v, u)
return _vec.unitize(crossProduct)
