This repository was archived by the owner on Jul 1, 2020. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathstep4.py
162 lines (142 loc) · 9.11 KB
/
step4.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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
import numpy as np
from vispy import gloo
from vispy import app
"""
4 этап.
Построить триангуляцию поверхности, отрисовать треугольники.
Реализовать вычисление цвета отдельных точек треугольинка.
Отрисовать тепловую карту.
"""
""" Это исходник вершинного шейдера, он будет вызывается для каждой вершины (точки) в отрисовываемой сцене.
Шейдеры пишутся на языке GLSL, который представляет собой C++ с рядом ограничений и расширений.
Рекомендуется установить последнюю координату gl_Position в 1 (запретить перспективу, так как карта двухмерная)"""
vert = ("""#version 120
attribute vec2 a_position;
attribute float a_height;
varying float z;
void main (void) {
z=(1-a_height)*0.5;
gl_Position = vec4(a_position.xy,z,1.0);
}"""
)
""" Это исходный текст шейдера фрагменов, он отвечает за определение цвета отображаемых на экране пикселя
(чуть сложнее, если разрешить смешивание цветов)."""
frag = ("""#version 120
varying float z;
void main() {
vec3 rgb=mix(vec3(1,0.5,0),vec3(0,0.5,1.0),z);
gl_FragColor = vec4(rgb,1);
}"""
)
class Surface(object):
""" объект состояния водной глади """
def __init__(self, size=(150, 200), nwave=5):
"""конструктор обьекта окна"""
self._size = size
self._wave_vector = nwave * np.random.randn(nwave, 2)
self._angular_frequency = np.random.randn(nwave) / nwave
self._phase = np.pi * self._angular_frequency / 2
self._amplitude = np.random.rand(nwave) / nwave
def position(self):
"""расчет координат точек прямоугольной решетки"""
xy = np.empty(self._size + (2,), dtype=np.float32)
xy[:, :, 0] = np.linspace(-1, 1, self._size[0])[:, None]
xy[:, :, 1] = np.linspace(-1, 1, self._size[1])[None, :]
return xy # xy координаты точек - прямоугольную решетку в квадрате [0,1]x[0,1]
def height(self, t):
"""расчет изменения высот водной глади в момент времени t"""
x = np.linspace(-1, 1, self._size[0])[:, None]
y = np.linspace(-1, 1, self._size[1])[None, :]
z = np.zeros(self._size, dtype=np.float32)
for n in range(self._amplitude.shape[0]):
z[:, :] += self._amplitude[n] * np.cos(x * self._wave_vector[n, 0] + y * self._wave_vector[n, 1] +
t * self._angular_frequency[n] + self._phase[n])
return z # массив высот водной глади в момент времени t
def wireframe(self):
"""расчет пар ближайших вершин"""
# горизонтальные отрезки
left = np.indices((self._size[0] - 1, self._size[1])) # координаты вершин, кроме крайнего правого столбца
right = left + np.array([1, 0])[:, None, None] # пересчет в координаты точек, кроме крайнего левого столбца
left_r = left.reshape((2, -1)) # преобразование массива точек в список
right_r = right.reshape((2, -1))
left_l = np.ravel_multi_index(left_r, self._size) # замена многомерных индексы линейными индексами
right_l = np.ravel_multi_index(right_r, self._size)
horizontal = np.concatenate((left_l[..., None], right_l[..., None]), axis=-1) # сбор массива пар точек
# вертикальные отрезки
bottom = np.indices((self._size[0], self._size[1] - 1)) # координаты вершин, кроме крайнего верхнего столбца
top = bottom + np.array([0, 1])[:, None, None] # пересчет в координаты точек, кроме крайнего нижнего столбца
bottom_r = bottom.reshape((2, -1)) # преобразование массива точек в список
top_r = top.reshape((2, -1))
bottom_l = np.ravel_multi_index(bottom_r, self._size) # замена многомерных индексы линейными индексами
top_l = np.ravel_multi_index(top_r, self._size)
vertical = np.concatenate((bottom_l[..., None], top_l[..., None]), axis=-1) # сбор массива пар точек
# print("left\n", left)
# print("right\n", right)
# print("left_r\n", left_r)
# print("right_r\n", right_r)
# print("left_l\n", left_l)
# print("right_l\n", right_l)
# print("horizontal\n", horizontal)
# print("bottom\n", bottom)
# print("top\n", top)
# print("bottom_r\n", bottom_r)
# print("top_r\n", top_r)
# print("bottom_l\n", bottom_l)
# print("top_l\n", top_l)
# print("vertical\n", vertical)
# print("segments\n", np.concatenate((horizontal,vertical),axis=0).astype(np.uint32))
# print("bottom[0]", bottom[0])
# print("np.size(bottom[0]", np.size(bottom[0]))
# print("np.size(bottom_r)", np.size(bottom_r))
return np.concatenate((horizontal, vertical), axis=0).astype(np.uint32) # массив пар ближайших вершин
def triangulation(self): # step4
"""расчет индексов вершин треугольников"""
a = np.indices((self._size[0] - 1, self._size[1] - 1)) # индексы всех точек A для каждого прямоугольника
b = a + np.array([1, 0])[:, None, None] # индексы всех точек B для каждого прямоугольника
c = a + np.array([1, 1])[:, None, None] # индексы всех точек C для каждого прямоугольника
d = a + np.array([0, 1])[:, None, None] # индексы всех точек D для каждого прямоугольника
a_r = a.reshape((2, -1)) # преобразование массива точек в список
b_r = b.reshape((2, -1))
c_r = c.reshape((2, -1))
d_r = d.reshape((2, -1))
a_l = np.ravel_multi_index(a_r, self._size) # замена многомерных индексы линейными индексами
b_l = np.ravel_multi_index(b_r, self._size)
c_l = np.ravel_multi_index(c_r, self._size)
d_l = np.ravel_multi_index(d_r, self._size)
abc = np.concatenate((a_l[..., None], b_l[..., None], c_l[..., None]), axis=-1) # сбор массива индексов вершин
acd = np.concatenate((a_l[..., None], c_l[..., None], d_l[..., None]), axis=-1)
return np.concatenate((abc, acd), axis=0).astype(np.uint32) # массив объединенных треугольников ABC и ACD
class Canvas(app.Canvas):
""" холст """
def __init__(self):
"""конструктор обьекта окна"""
app.Canvas.__init__(self, title="step 4", size=(500, 500), vsync=True)
gloo.set_state(clear_color=(0, 0, 0, 1), depth_test=False, blend=False)
self.program = gloo.Program(vert, frag)
self.surface = Surface() # обьект, который будет давать состояние поверхности
self.program["a_position"] = self.surface.position() # xy=const шейдеру,
self.triangles = gloo.IndexBuffer(self.surface.triangulation()) # step4
self.t = 0 # t - time
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.activate_zoom()
self.show()
def activate_zoom(self):
"""установка размера окна"""
self.width, self.height = self.size
print(self.width, self.height)
gloo.set_viewport(0, 0, *self.physical_size)
def on_draw(self, event):
"""перерисовка окна"""
gloo.clear()
self.program["a_height"] = self.surface.height(self.t) # пересчет высот для текущего времени
self.program.draw('triangles', self.triangles) # step4
def on_timer(self, event):
"""приращение времени с обновлением изображения"""
self.t += 0.01
self.update()
def on_resize(self, event):
"""данные о новом размере окна в OpenGL"""
self.activate_zoom()
if __name__ == '__main__':
c = Canvas() # обьект приложения
app.run() # обработчик событий.