def flat(self, location, width, height):
w = width/2
h = height/2
return Screen(
Vector3(location[0] - width, 0.0, location[0] + height),
Vector3(location[0] + width, 0.0, location[0] + height),
Vector3(location[0] - width, 0.0, location[0] - height),
Vector3(location[0] + width, 0.0, location[0] - height)
)
def get_ico_sphere(subdivisions):
with open(f'shapes/icosphere_sub{subdivisions}.data', 'rb') as f:
triangles_pkl = pickle.load(f)
triangles = []
for t in triangles_pkl:
triangles.append(
Triangle3(Vector3(t[0][0], t[0][1], t[0][2]),
Vector3(t[1][0], t[1][1], t[1][2]),
Vector3(t[2][0], t[2][1], t[2][2])))
return triangles
def generate_triangle_pairs(self):
self.triangles = []
for i in range(len(self._line) - 1):
prev = Vector3(0.0, 0.0, 0.0) if i == 0 else self._line[i - 1]
nxt = Vector3(0.0, 0.0,
0.0) if i == len(self._line) - 2 else self._line[i +
2]
self.triangles.append(
LineTriangle3(prev, self._line[i], self._line[i + 1], nxt,
self.ind_to_pos(i), self.ind_to_pos(i + 1),
self.width))
return self.triangles
def create_grid(self, grid_from, grid_to, grid_increment, radius):
for i in frange(grid_from, grid_to + grid_increment, grid_increment):
for j in frange(grid_from, grid_to + grid_increment,
grid_increment):
polar = cart_to_polar((i, j), grid_to)
cw = color_wheel(polar[0], polar[1])
self.spheres.append(Sphere(radius, Vector3(i, j, 0.0), cw))
def zoom(self, renderer, time, frametime):
if abs(frametime) > 1500000:
return
if 2 < time and self.z > 2:
self.camera_orthographic.update(self.z, self.z, -self.z, -self.z, 0.1, 1000)
if self.camera_orthographic.position.z > 1:
self.camera_orthographic.position -= Vector3(0.0, 0.0, 5*frametime)
self.z -= frametime
def setup(self, data, labels):
self.spheres = SphereGrid(-2, 2, 1, radius = 0.03)
self.lines = LineGrid(-20,20, grid_increment=2, sections=500)
self.grid = Grid(-20, 20, grid_width=0.0008)
self.vector = VectorR.straight_vector(Vector3(0,0,0.01), Vector3(4,4,0.01), 0.5, 0.026)
self.spherer = Sphere(0.01, Vector3(0,0,0))
self.datas = SphereCollection(0.003)
for d in range(len(data)):
self.datas.add(
Vector(*data[d]).pad_to(3),
Vector(*labels[d]).pad_to(3),
)
self.screen = Screen(
Vector3(0,0,5),
Vector3(5,5,6),
Vector3(0,0,0),
Vector3(5,5,1)
)
self.scene.add_scene_object(self.grid)
# self.scene.add_scene_object(self.vector)
# self.scene.add_scene_object(self.spheres)
self.scene.add_scene_object(self.lines)
self.scene.add_scene_object(self.datas)
# self.scene.add_scene_object(self.spherer)
for l in self.neural_network.layers_history[-1]:
mat = Matrix.from_array(l['weights']).pad_to(3)
trans = Vector.from_array(l['bias']).pad_to(3)
self.scene.add_mba_step_transformation(mat, trans, SIGMOID_FUNC, (0,5), (0,5), (0,5))
def __init__(self, data, layers, labels):
if len(data) != len(labels):
raise RuntimeError("labels and data dont match")
self.renderer = WindowRenderer()
self.ang = 0
self.camera_perspective = PerspectiveCamera(Vector3(0.0, 5.0, 5.0), 0.1, 1000, 1, math.pi/3)
self.camera_perspective.look_at(Vector3(0.0,0.0,0.0), Vector3(0.0,0.0,1.0))
self.z = 20
self.camera_orthographic = OrthographicCamera(Vector3(0.0, 0.0, 100.0), self.z, self.z, -self.z, -self.z, 0.1, 1000)
self.camera_orthographic.look_at(Vector3(0.0,0.0,0.0), Vector3(1.0,0.0,0.0))
self.scene = NNScene(self.camera_orthographic, self.renderer)
self.scene.renderer.add_before_render_function(self.zoom)
# self.scene_out = NNScene(self.camera_perspective, self.renderer, size = (3000, 3000))
# self.scene_out.renderer.add_before_render_function(self.rotate)
# self.scene = NNScene(self.camera_orthographic, self.renderer)
# self.scene.renderer.add_before_render_function(self.zoom)
self.neural_network = NNTrainer(data, layers, labels)
self.neural_network.n_training_epochs(100000)
self.setup(data, labels)
def generate_unit_icosphere(self, subdivisions):
T = 4**subdivisions
verts = [0 for i in range((10 * T + 2) * 3)]
set_arr(verts, 0, self.init_verts)
tris = self.init_tris
v = 12
mid_cache = None if subdivisions == 0 else {}
for i in range(subdivisions):
# subdivide each triangle into 4 triangles
triangles_next = [0 for _ in range(len(tris) * 4)]
for k in range(0, len(tris), 3):
v1 = tris[k]
v2 = tris[k + 1]
v3 = tris[k + 2]
(a, v) = self._add_mid_point(v1, v2, verts, mid_cache, v)
(b, v) = self._add_mid_point(v2, v3, verts, mid_cache, v)
(c, v) = self._add_mid_point(v3, v1, verts, mid_cache, v)
set_arr(triangles_next, k * 4,
[v1, a, c, v2, b, a, v3, c, b, a, b, c])
tris = triangles_next
verts_temp = []
for i in range(0, len(verts), 3):
curr_vert = Vector3(verts[i], verts[i + 1], verts[i + 2])
verts_temp.append(curr_vert.normalize())
triangles = []
for k in range(0, len(tris), 3):
v1 = verts_temp[tris[k + 0]]
v2 = verts_temp[tris[k + 1]]
v3 = verts_temp[tris[k + 2]]
triangles.append(Triangle3(v1, v2, v3))
return triangles
def create_grid(self, grid_from, grid_to, grid_width, grid_increment,
sections):
grid = []
for i in frange(grid_from, 0, grid_increment):
line = Line(
self.straight_line_pts(sections, Vector3(i, grid_from, 0),
Vector3(i, grid_to, 0)), grid_width,
(0.75, 0.75, 0.75))
grid.append(line)
for i in frange(1, grid_to + 1, grid_increment):
line = Line(
self.straight_line_pts(sections, Vector3(i, grid_from, 0),
Vector3(i, grid_to, 0)), grid_width,
(0.75, 0.75, 0.75))
grid.append(line)
for i in frange(grid_from, 0, grid_increment):
line = Line(
self.straight_line_pts(sections, Vector3(grid_from, i, 0),
Vector3(grid_to, i, 0)), grid_width,
(0.75, 0.75, 0.75))
grid.append(line)
for i in frange(1, grid_to + 1, grid_increment):
line = Line(
self.straight_line_pts(sections, Vector3(grid_from, i, 0),
Vector3(grid_to, i, 0)), grid_width,
(0.75, 0.75, 0.75))
grid.append(line)
line = Line(
self.straight_line_pts(sections, Vector3(0, 0, grid_from),
Vector3(0, 0, grid_to)), grid_width,
(1.0, 0.0, 0.0))
grid.append(line)
line = Line(
self.straight_line_pts(sections, Vector3(0, grid_from, 0),
Vector3(0, grid_to, 0)), grid_width,
(0.0, 1.0, 0.0))
grid.append(line)
line = Line(
self.straight_line_pts(sections, Vector3(grid_from, 0, 0),
Vector3(grid_to, 0, 0)), grid_width,
(0.0, 0.0, 1.0))
grid.append(line)
return grid
def rotate(self, renderer, time, frametime):
if abs(frametime) > 1500000:
return
self.camera_perspective.position = Vector3(10*math.cos(self.ang), 10*math.sin(self.ang), 5)
self.ang += frametime*0.2
def __init__(self, byte_array):
# Configure to use pyglet window
settings.WINDOW['class'] = 'moderngl_window.context.pyglet.Window'
settings.WINDOW['size'] = (720, 720)
settings.WINDOW['aspect_ratio'] = 1
self.wnd = moderngl_window.create_window_from_settings()
self.ctx = self.wnd.ctx
self.ctx.enable(moderngl.DEPTH_TEST)
# register event methods
self.wnd.resize_func = self.resize
self.wnd.iconify_func = self.iconify
self.wnd.key_event_func = self.key_event
self.wnd.mouse_position_event_func = self.mouse_position_event
self.wnd.mouse_drag_event_func = self.mouse_drag_event
self.wnd.mouse_scroll_event_func = self.mouse_scroll_event
self.wnd.mouse_press_event_func = self.mouse_press_event
self.wnd.mouse_release_event_func = self.mouse_release_event
self.wnd.unicode_char_entered_func = self.unicode_char_entered
self.wnd.close_func = self.close
with open("shaders/tri_vert_shader.glsl") as f:
vertex_shader = f.read()
with open("shaders/tri_frag_shader.glsl") as f:
fragment_shader = f.read()
self.prog = self.ctx.program(
vertex_shader=vertex_shader,
fragment_shader=fragment_shader,
)
self.clear_color = (1.0, 1.0, 1.0)
eye = Vector3(5.0, 0.0, 5.0)
center = Vector3(0.0, 0.0, 0.0)
up = Vector3(0.0, 0.0, 1.0)
self.prog['camera_pos'].value = eye.to_tuple()
self.look = Matrix4.look_at(center, eye, up)
self.perspective_matrix = Matrix4.perspective_projection(
0.1, 1000, 1, math.pi / 3)
self.orthoganal_matrix = Matrix4.orthographic_projection(
5, 5, -5, -5, 0.1, 1000)
self.proj_matrix = self.look @ self.perspective_matrix
self.prog['projection_matrix'].value = self.proj_matrix.to_tuple()
self.prog['time'].value = 0
self.prog['change_matrix'].value = Matrix3.random(-1, 1).to_tuple()
self.prog['change_bias'].value = Vector3.random(-5, 5).to_tuple()
self.prog['matrix_change_start_stop_time'].value = (0, 5)
self.prog['bias_change_start_stop_time'].value = (5, 10)
self.prog['activation_function_change_start_stop_time'].value = (10,
15)
self.shader_args = ("3f4 3f4 3f4 3f4 2f4 3f4 3f4 1f4 3f4 u1 /v",
"from_vert", "to_vert", "tangent_translate_from",
"tangent_translate_to",
"point_transform_start_stop_time", "normal",
"light_direction", "width_scale", "in_color",
"type")
self.vbo = self.ctx.buffer(byte_array)
self.vao = self.ctx.vertex_array(self.prog, [
(self.vbo, *self.shader_args),
])