-
Notifications
You must be signed in to change notification settings - Fork 0
/
pipeline.py
132 lines (98 loc) · 3.22 KB
/
pipeline.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
import copy
import openmesh as om
import numpy as np
from transformations import getGeometricCenter
from constantShading import applyConstantShading
def isMeshVisible(mesh, dNear, dFar):
GC = getGeometricCenter(mesh)
#print(GC)
if -GC[2] < dNear or -GC[2] > dFar:
return False
else:
return True
def normalize(n):
norm = np.linalg.norm(n)
if norm == 0:
print("WARNING: norm == 0")
else:
n = n / norm
return n
def getVisibleFaces(mesh, VRP, P):
#Returns only the visible faces of the mesh
visibleMesh = copy.deepcopy(mesh)
n = normalize(VRP - P)
#check wich faces are not visible and delete them
for fh in visibleMesh.faces():
faceNormal = np.sum(visibleMesh.calc_face_normal(fh)*n)
if faceNormal <= 0:
visibleMesh.delete_face(fh)
#call garbage collector
visibleMesh.garbage_collection()
return visibleMesh
def sru2src(VRP, P=np.array([0,0,0]), viewUp=np.array([0,1,0])):
#returns the SRU to SRC matrix
n = normalize(VRP - P)
v = viewUp - (np.sum(viewUp*n)*n)
v = normalize(v)
u = np.cross(v, n)
m = np.eye(4)
m[0,:3] = u
m[1,:3] = v
m[2,:3] = n
#Optimize multiplication by the translation matrix
m[0,3] = -np.dot(VRP, u)
m[1,3] = -np.dot(VRP, v)
m[2,3] = -np.dot(VRP, n)
return m
def perspProj(dist):
#returns the perspective transformation matrix
m = np.eye(4)
m[2,2] = 1
m[3,3] = 0
m[3,2] = -1/dist
return m
def proj2srt(xMin, xMax, yMin, yMax, uMin, uMax, vMin, vMax):
#returns projection matrix
# xMin = -width/2
# xMax = width/2
# yMin = -height/2
# yMax = height/2
m = np.eye(4)
m[0,0] = (uMax-uMin)/(xMax-xMin)
m[1,1] = (vMin-vMax)/(yMax-yMin)
m[0,3] = (-xMin*(uMax-uMin)/(xMax-xMin))+uMin
m[1,3] = (yMin*(vMax-vMin)/(yMax-yMin))+vMax
return m
def buildPipeline(VRP, dist, xMin, xMax, yMin, yMax, uMin, uMax,
vMin, vMax, P=np.array([0,0,0]), viewUp=np.array([0,1,0]), perspOn=False):
if perspOn: m = np.dot(perspProj(dist), sru2src(VRP, P, viewUp))
else: m = sru2src(VRP, P, viewUp)
return np.dot(proj2srt(xMin, xMax, yMin, yMax, uMin, uMax, vMin, vMax),m)
def computeVertices(mesh, pipelineMatrix):
#pass the copied mesh as parameter not the original one
#pontos = np.c_[mesh.points()]
#pontos = np.c_[pontos, np.ones(np.shape(pontos)[0])].transpose()
#pontos = np.dot(pipelineMatrix, pontos)
#pontos[0] = pontos[0]/pontos[3]
#pontos[1] = pontos[1]/pontos[3]
#pontos[3] = pontos[3]/pontos[3]
#return pontos
for vh in mesh.vertices():
coord = np.append(copy.deepcopy(mesh.point(vh)),1)
coord = np.dot(pipelineMatrix, coord)
mesh.point(vh)[0] = coord[0]/coord[3]
mesh.point(vh)[1] = coord[1]/coord[3]
mesh.point(vh)[2] = coord[2]
return mesh
def convertMesh2SRT(mesh, VRP, dist, xMin, xMax, yMin, yMax, uMin, uMax,
vMin, vMax, P, viewUp, perspOn, lAmbiente, lPontual, lPontualCord, kA, kD, kS, n):
#print("-"*10)
#print("convertMesh2SRT")
#print(f"xMin={xMin}, xMax={xMax}, yMin={yMin}, yMax={yMax}, uMin={uMin}, uMax={uMax}, vMin={vMin}, vMax={vMax}")
#print("-"*10)
matrix = buildPipeline(VRP, dist, xMin, xMax, yMin, yMax, uMin, uMax,
vMin, vMax, P, viewUp, perspOn)
mesh = getVisibleFaces(copy.deepcopy(mesh), VRP, P)
applyConstantShading(mesh, VRP, lAmbiente, lPontual, lPontualCord, kA, kD, kS, n)
meshCopy = computeVertices(mesh, matrix)
return meshCopy