def __init__(self, *args, **kwargs): """ Initialize the transform. """ code = library.get("transforms/trackball-pan.glsl") Transform.__init__(self, code, *args, **kwargs) self._aspect = Transform._get_kwarg("aspect", kwargs) or 1 self._znear = Transform._get_kwarg("znear", kwargs) or 2.0 self._zfar = Transform._get_kwarg("zfar", kwargs) or 1000.0 theta = Transform._get_kwarg("theta", kwargs) or 45 phi = Transform._get_kwarg("phi", kwargs) or 45 self._distance = Transform._get_kwarg("distance", kwargs) or 8 self._zoom = Transform._get_kwarg("zoom", kwargs) or 35 self._width = 1 self._height = 1 self._window_aspect = 1 self._view_x = 0 self._view_y = 0 self._shift = False self._trackball = _trackball.Trackball(45,45) self._projection = np.eye(4, dtype=np.float32) self._view = np.eye(4, dtype=np.float32) glm.translate(self._view, 0, 0, -abs(self._distance))
def distance(self, distance): """ Distance from the trackball to the object """ self._distance = abs(distance) self._view = np.eye(4, dtype=np.float32) glm.translate(self._view, 0, 0, -abs(self._distance)) self["view"] = self._view
def matrix_model(model): glm.scale(model, self.size, self.size, self.size) glm.rotate(model, self.deg_y, 1, 0, 0) glm.rotate(model, self.deg_x, 0, 0, 1) glm.translate(model, self.mov_x, -self.mov_y, 0) # model[3,3] = 1 return model
def __init__(self, *args, **kwargs): """ Initialize the transform. """ code = library.get("transforms/trackball-pan.glsl") Transform.__init__(self, code, *args, **kwargs) self._aspect = Transform._get_kwarg("aspect", kwargs) or 1 self._znear = Transform._get_kwarg("znear", kwargs) or 2.0 self._zfar = Transform._get_kwarg("zfar", kwargs) or 1000.0 theta = Transform._get_kwarg("theta", kwargs) or 45 phi = Transform._get_kwarg("phi", kwargs) or 45 self._distance = Transform._get_kwarg("distance", kwargs) or 8 self._zoom = Transform._get_kwarg("zoom", kwargs) or 35 self._width = 1 self._height = 1 self._window_aspect = 1 self._view_x = 0 self._view_y = 0 self._shift = False self._trackball = _trackball.Trackball(45, 45) self._projection = np.eye(4, dtype=np.float32) self._view = np.eye(4, dtype=np.float32) glm.translate(self._view, 0, 0, -abs(self._distance))
def render(self, dt): if not self.draw: return False # View view = np.eye(4, dtype=np.float32) glm.translate(view, self.params["posx"], self.params["posy"], self.params["posz"]) self.program['view'] = view # Model model = np.eye(4, dtype=np.float32) glm.rotate(model, self.params["theta"], 0, 0, 1) glm.rotate(model, self.params["phi"], 0, 1, 0) self.program['model'] = model # Modulations self.program['radius'] = self.params["size"] self.program['cutoff'] = self.params['cutoff'] position = self.program['position'] angles = np.linspace(0, np.pi * self.params["ratio"] * n, n) thet = np.linspace(0, np.pi * self.params["ratio"] * 2, n) distances = np.linspace(0, (0.00005 + self.params["distance"]) * n, n) position[:, 0] = distances * np.sin(angles) * np.cos(thet) position[:, 1] = distances * np.sin(angles) * np.sin(thet) position[:, 2] = distances * np.cos(angles) # Drawing self.window.clear() self.program.draw(gl.GL_POINTS) self.draw = False return True
def distance(self, value): """ Distance of the camera to the origin """ if value > 1: self._distance = value self._view = np.eye(4, dtype=np.float32) glm.translate(self._view, 0, 0, -self._distance) self["view"] = self._view
def update(self): model = correctly_rotated_model_matrix() glm.rotate(model, self.rotation[0], 1, 0, 0) glm.rotate(model, self.rotation[1], 0, 1, 0) glm.rotate(model, self.rotation[2], 0, 0, 1) glm.translate(model, self.position[0], self.position[1], self.position[2]) glm.scale(model, self.scale[0], self.scale[1], self.scale[2]) self.model_matrix = model
def on_draw(dt): window.clear() global ALL_DATA, ALL_N, n, n_particles global rng global omega, phi_g, phi_p global positions, velocities, fitness_scores, best_positions, best_fitness_scores global global_best_position, global_best_fitness Rp = rng.rand() Rg = rng.rand() velocities *= omega velocities += (best_positions - positions) * (phi_p * Rp) velocities += (global_best_position - positions) * (phi_g * Rg) positions += velocities results = Parallel(n_jobs=1)(delayed(evaluate_particle)(particle, pos) for particle, pos in enumerate(positions)) fitness_scores = np.array([f[2] for f in results], dtype=np.float32) diff_indices = np.where(fitness_scores < best_fitness_scores)[0] if len(diff_indices) > 0: best_positions[diff_indices, :] = positions[diff_indices, :] best_fitness_scores[diff_indices] = fitness_scores[diff_indices] new_best_fitness_indices = np.where( fitness_scores < global_best_fitness)[0] if len(new_best_fitness_indices) > 0: new_best_fitness_value = np.min( fitness_scores[new_best_fitness_indices]) new_best_fitness_arg = np.argmin( fitness_scores[new_best_fitness_indices]) global_best_fitness = new_best_fitness_value global_best_position = positions[new_best_fitness_arg] # # # global program ALL_DATA = np.vstack((VIEW_DATA, positions)) program["position"] = 0.75 * ALL_DATA # # # global theta, phi, translate global sx, sy, sz window.clear() program.draw(gl.GL_POINTS) model = np.eye(4, dtype=np.float32) glm.scale(model, sx, sy, sz) glm.rotate(model, theta, 1, 0, 0) glm.rotate(model, phi, 0, 1, 0) glm.translate(model, tx, ty, tz) program["model"] = model
def matrix_model(): model = np.eye(4, dtype=np.float32) #model *= size glm.rotate(model, theta, 1, 0, 0) glm.rotate(model, -phi, 0, 1, 0) glm.translate(model, tx, ty, 0) glm.scale(model, size) #model[3,3] = 1 return model
def do_update( self ): M = np.eye( 4 ) M = glm.rotate( M, -90, 1, 0, 0 ) # rotates CCW glm.translate( M, -self.view_xyz[0], -self.view_xyz[1], -self.view_xyz[2] ) glm.rotate( M, self.view_hpr[0], 0, 1, 0 ) glm.rotate( M, self.view_hpr[1], 1, 0, 0 ) self._model = M self["model"] = self._model
def on_draw(dt): nonlocal frame, x, y, z, theta, phi, gamma # Export screenshot gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer) if frame > 2: # Skip empty zero frame if (frame) % 3 == 0: pbar.update() gt.append( [f'{(frame-3)//3:05d}.png', x, y, z, theta, phi, gamma]) png.from_array(framebuffer, 'RGB').save( root / 'images' / f'{(frame-3)//3:05d}.png') elif (frame) % 3 == 1: png.from_array(framebuffer, 'RGB').save( root / 'no_rotation' / f'{(frame-4)//3:05d}.png') elif (frame) % 3 == 2: png.from_array(framebuffer, 'RGB').save( root / 'no_translation' / f'{(frame-5)//3:05d}.png') if (frame - 1) % 3 == 0: theta = np.random.random_sample() * 360 x, y = np.random.random_sample(2) * (max_xy - min_xy) + min_xy if not fixed_z: z = np.random.random_sample() * (max_z - min_z) + min_z if shape == 'cube': phi = np.random.random_sample() * 180 if shape in shapes: phi = np.random.random_sample() * 180 gamma = np.random.random_sample() * 360 window.clear() # Fill cube gl.glDisable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_POLYGON_OFFSET_FILL) cube['u_color'] = 1, 1, 1, 1 cube.draw(gl.GL_TRIANGLES, I) # Rotate cube view = cube['u_view'].reshape(4, 4) model = np.eye(4, dtype=np.float32) if (frame - 1) % 3 != 1: glm.rotate(model, theta, 0, 0, 1) glm.rotate(model, phi, 0, 1, 0) glm.rotate(model, gamma, 1, 0, 0) # Translate cube if (frame - 1) % 3 != 2: glm.translate(model, x, y, z) cube['u_model'] = model cube['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T) frame += 1
def __init__(self, *args, **kwargs): code = library.get("transforms/pvm.glsl") Transform.__init__(self, code, *args, **kwargs) self._fovy = 40 self._znear, self._zfar = 2.0, 100.0 self._view = np.eye(4, dtype=np.float32) self._model = np.eye(4, dtype=np.float32) self._projection = np.eye(4, dtype=np.float32) glm.translate(self._view, 0, 0, -5)
def __init__(self, *args, **kwargs): code = get_code("pvm.glsl") Transform.__init__(self, code, *args, **kwargs) self._fovy = 40 self._znear, self._zfar = 2.0, 100.0 self._view = np.eye(4, dtype=np.float32) self._model = np.eye(4, dtype=np.float32) self._projection = np.eye(4, dtype=np.float32) glm.translate(self._view, 0, 0, -5)
def get_view(self): view = np.eye(4, dtype=np.float) glm.translate( view, *(-self._position )) # shift the world so that the camera is at the origin glm.yrotate(view, self._yaw) # rotate the world so that it faces the camera glm.xrotate(view, self._pitch) glm.zrotate(view, self._roll) glm.scale(view, 1, -1, -1) return view
def __init__(self, *args, **kwargs): code = library.get("transforms/pvm.glsl") Transform.__init__(self, code, *args, **kwargs) self._width = None self._height = None self._distance = Transform._get_kwarg("distance", kwargs) or 5 self._fovy = Transform._get_kwarg("fovy", kwargs) or 40 self._znear = Transform._get_kwarg("znear", kwargs) or 2.0 self._zfar = Transform._get_kwarg("zfar", kwargs) or 100.0 self._view = np.eye(4, dtype=np.float32) self._model = np.eye(4, dtype=np.float32) self._projection = np.eye(4, dtype=np.float32) glm.translate(self._view, 0, 0, -self._distance)
def __init__(self, *args, **kwargs): #if "code" not in kwargs.keys(): code = get_code("pvm.glsl") Transform.__init__(self, code, *args, **kwargs) self._fovy = 25 self._znear, self._zfar = 2.0, 100.0 self._trackball = _trackball.Trackball(45,45) self._viewport = None self._model = self._trackball.model self._projection = np.eye(4, dtype=np.float32) self._view = np.eye(4, dtype=np.float32) self._aspect = 1.0 glm.translate(self._view, 0, 0, -8)
def __init__(self, *args, **kwargs): """ Initialize the transform. Note that parameters must be passed by name (param=value). Kwargs parameters ----------------- aspect : float (default is None) Indicate what is the aspect ratio of the object displayed. This is necessary to convert pixel drag move in oject space coordinates. znear : float, float (default is 2) Near clip plane zfar : float, float (default is 1000) Distance clip plane theta : float (default is 45) Angle (in degrees) around the z axis phi: float (default is 45) Angle (in degrees) around the x axis distance: float (default is 8) Distance from the trackball to the object zoom : float (default is 35) Zoom level """ code = library.get("transforms/trackball.glsl") Transform.__init__(self, code, *args, **kwargs) self._aspect = Transform._get_kwarg("aspect", kwargs) or 1 self._znear = Transform._get_kwarg("znear", kwargs) or 2.0 self._zfar = Transform._get_kwarg("zfar", kwargs) or 1000.0 theta = Transform._get_kwarg("theta", kwargs) or 45 phi = Transform._get_kwarg("phi", kwargs) or 45 self._distance = Transform._get_kwarg("distance", kwargs) or 8 self._zoom = Transform._get_kwarg("zoom", kwargs) or 35 self._width = 1 self._height = 1 self._window_aspect = 1 self._trackball = _trackball.Trackball(45,45) self._projection = np.eye(4, dtype=np.float32) self._view = np.eye(4, dtype=np.float32) glm.translate(self._view, 0, 0, -abs(self._distance))
def on_draw(dt): nonlocal depth color_buf = np.zeros((imgsize, imgsize, 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((imgsize, imgsize), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() window.clear() # Fill cube gl.glDisable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_POLYGON_OFFSET_FILL) gl.glClearColor(0.0, 0.0, 0.0, 0.0) # Rotate cube model = np.eye(4, dtype=np.float32) # model = R_ @ model glm.rotate(model, R[0], 0, 0, 1) glm.rotate(model, R[1], 0, 1, 0) glm.rotate(model, R[2], 1, 0, 0) # Translate cube glm.translate(model, *t) cube['u_model'] = model # cube['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T) cube.draw(gl.GL_TRIANGLES, I) # depth = np.zeros((shape[0], shape[1], 4), dtype=np.float32) # gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, depth) # depth.shape = shape[0], shape[1], 4 # depth = depth[::-1, :] # depth = depth[:, :, 0] # Depth is saved in the first channel # Export screenshot gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB, gl.GL_FLOAT, depthbuffer) # png.from_array(np.floor((depthbuffer - 0) / depthbuffer.max() * 255).astype(np.uint8), # 'RGB').save('./images' + # f'depth{time.time()}.png') fbo.deactivate() fbo.delete() depth = depthbuffer.reshape((128, 128, 3))[::-1, :, 0]
def __init__(self, *args, **kwargs): """ Initialize the transform. Note that parameters must be passed by name (param=value). Kwargs parameters ----------------- aspect : float (default is None) Indicate what is the aspect ratio of the object displayed. This is necessary to convert pixel drag move in oject space coordinates. znear : float, float (default is 2) Near clip plane zfar : float, float (default is 1000) Distance clip plane theta : float (default is 45) Angle (in degrees) around the z axis phi: float (default is 45) Angle (in degrees) around the x axis distance: float (default is 8) Distance from the trackball to the object zoom : float (default is 35) Zoom level """ code = library.get("transforms/trackball.glsl") Transform.__init__(self, code, *args, **kwargs) self._aspect = Transform._get_kwarg("aspect", kwargs) or 1 self._znear = Transform._get_kwarg("znear", kwargs) or 2.0 self._zfar = Transform._get_kwarg("zfar", kwargs) or 1000.0 theta = Transform._get_kwarg("theta", kwargs) or 45 phi = Transform._get_kwarg("phi", kwargs) or 45 self._distance = Transform._get_kwarg("distance", kwargs) or 8 self._zoom = Transform._get_kwarg("zoom", kwargs) or 35 self._width = 1 self._height = 1 self._window_aspect = 1 self._trackball = _trackball.Trackball(45, 45) self._projection = np.eye(4, dtype=np.float32) self._view = np.eye(4, dtype=np.float32) glm.translate(self._view, 0, 0, -abs(self._distance))
def wheelEvent(self, wheel_event): if self._render_mode == self.TEXTURE_RENDER_MODE: return scroll_steps = wheel_event.angleDelta().y( ) / 8 / 15 # Get actual number of steps (default is 15 deg/step) view_y = self._world_to_view[-1, 2] if (view_y >= 0 and scroll_steps > 0) or (view_y <= -self._far_clip_z and scroll_steps < 0): return distance_speedup = np.clip(abs(view_y) / 4.0, 1.0, 10.0) glm.translate(self._world_to_view, 0, 0, scroll_steps * self._scroll_speed * distance_speedup)
def on_draw(dt): nonlocal phi, theta, omega, dx, dy, dz, scale, d model = np.eye(4, 4, dtype=np.float32) glm.xrotate(model, omega) glm.yrotate(model, phi) glm.zrotate(model, theta) glm.scale(model, scale, scale, scale) glm.translate(model, dx, dy, dz) cube['model'] = model cube['color'] = color window.clear() cube.draw(gl.GL_TRIANGLES, I)
def on_mouse_scroll(x, y, dx, dy): if self.size + dy * 0.1 < 0.1: self.size = 0.1 else: # self.size += dy * 0.1 # self.zoom += dy*1 self.u_view = glm.translate(self.u_view, 0, 0, dy)
def on_mouse_scroll(x, y, dx, dy): if self.size + dy * 0.1 < 0.1: self.size = 0.1 else: # self.size += dy * 0.1 # self.zoom += dy*1 self.u_view = glm.translate(self.u_view , 0, 0, dy)
def on_draw(dt): nonlocal phi, theta, omega, dx, dy, dz, scale, d matrix = np.eye(4, 4, dtype=np.float32) glm.xrotate(matrix, omega) glm.yrotate(matrix, phi) glm.zrotate(matrix, theta) glm.scale(matrix, scale, scale, scale) glm.translate(matrix, dx, dy, dz) result = [np.matmul([*p, 1], matrix)[0:3] for p in V] cube['position'] = [project(*p, d) for p in result] window.clear() cube.draw(gl.GL_LINE_LOOP, I)
def init(self): view = np.eye(4, dtype=np.float32) glm.translate(view, 0, 0, -20) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) p = gloo.Program(ge.vertex_shaders['v1'], ge.fragment_shaders['f1']) self['program_shader'] = p if self['vertex_buffer'] is None: self.set_vertex(self['vertex']) if self['index_buffer'] is None: self.set_index(self['index']) if game.window is not None: self.set_projection(game.window.width, game.window.height) self.set_color(self['color']) p['u_view'] = view p['u_projection'] = projection p['u_model'] = model p.bind(self['vertex_buffer'])
def render(self, dt): self.window.activate() self.window.clear() if self.iMat is not None: self.iMat = np.eye(4, dtype=np.float32) if not self.gimbal: glm.xrotate(self.iMat, self.horizontal_angle) glm.yrotate(self.iMat, self.vertical_angle) else: self.position = [0., 0., self.params["distance"]] glm.translate(self.iMat, *self.position) if self.gimbal: glm.xrotate(self.iMat, self.params["horizontal_angle"]) glm.yrotate(self.iMat, self.params["vertical_angle"]) self.params["iMat"] = self.iMat for p in self.program_params: self.program[p] = self.params[p] dt = dt / self.fps if self.iTime: self.program["iTime"] = dt try: self.program.draw(gl.GL_TRIANGLE_STRIP) if self.old_program: self.old_program.delete() del self.old_program self.old_program = None print("Loaded new program!") except RuntimeError: if not self.old_program: raise self.old_program.draw(gl.GL_TRIANGLE_STRIP) self.program.delete() del self.program self.program = self.old_program self.old_program = None self.paused = True if self.title == "Map": gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_ONE_MINUS_DST_COLOR, gl.GL_ZERO) self.point_program.draw(gl.GL_POINTS) self.prev_params = copy.deepcopy(self.params)
def _draw_circles(self, centers): gl.glEnable(gl.GL_BLEND) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glDisable(gl.GL_DEPTH_TEST) gl.glLineWidth(3) for i in range(len(centers)): center = centers[i] radius = self.__harmonics[i].radius model = np.eye(4, dtype=np.float32) glm.scale(model, radius / 2, radius / 2, 1) glm.translate(model, center[0] / 2, center[1] / 2, 0) self.__circles_program[self.u_model] = model self.__circles_program[self.u_color] = self.__circle_color self.__circles_program.draw(gl.GL_TRIANGLE_FAN, self.__circle_i) self.__circles_program[self.u_color] = self.__ocircle_color self.__circles_program.draw(gl.GL_LINE_LOOP, self.__ocircle_i)
def draw(fx): window = app.Window(width=800, height=800, color=(1,1,1,1)) pos, rad, col = next(fx) n = len(rad) program = gloo.Program(vertex, fragment, count=n) view = np.eye(4, dtype=np.float32) glm.translate(view, 0, 0, -5) program['position'] = pos program['radius'] = rad program['fg_color'] = 0,0,0,1 program['bg_color'] = col program['linewidth'] = 1.0 program['antialias'] = 1.0 program['model'] = np.eye(4, dtype=np.float32) program['projection'] = np.eye(4, dtype=np.float32) program['view'] = view @window.event def on_draw(dt): global theta, phi program['position'], program['radius'], program['bg_color'] = next(fx) window.clear() program.draw(gl.GL_POINTS) theta += .5 phi += .5 model = np.eye(4, dtype=np.float32) glm.rotate(model, theta, 0, 0, 1) glm.rotate(model, phi, 0, 1, 0) program['model'] = model @window.event def on_resize(width,height): program['projection'] = glm.perspective(45.0, width / float(height), 1.0, 1000.0) gl.glEnable(gl.GL_DEPTH_TEST) app.run()
def display_cloud(cloud): window = app.Window(width=800, height=800, color=(1, 1, 1, 1)) @window.event def on_draw(dt): global theta, phi, translate window.clear() program.draw(gl.GL_POINTS) theta += .5 phi += .5 model = np.eye(4, dtype=np.float32) glm.rotate(model, theta, 0, 0, 1) glm.rotate(model, phi, 0, 1, 0) program['model'] = model @window.event def on_resize(width, height): program['projection'] = glm.perspective(45.0, width / float(height), 1.0, 1000.0) n = len(cloud) program = gloo.Program(vertex, fragment, count=n) view = np.eye(4, dtype=np.float32) glm.translate(view, 0, 0, -5) program['position'] = cloud program['radius'] = [5] * n program['fg_color'] = 0, 0, 0, 1 colors = np.random.uniform(0.75, 1.00, (n, 4)) colors[:, 3] = 1 program['bg_color'] = colors program['linewidth'] = 1.0 program['antialias'] = 1.0 program['model'] = np.eye(4, dtype=np.float32) program['projection'] = np.eye(4, dtype=np.float32) program['view'] = view gl.glEnable(gl.GL_DEPTH_TEST) app.run()
def on_key_press(symbol, modifiers): global alpha dx=dy=dz=0 shift = True if modifiers == 1 else False mat = np.eye(4, dtype=np.float32) letra = '' if symbol==-1: return letra = chr(symbol) if letra =='W': dz=-0.1 elif letra == 'S': dz=0.1 elif letra=='D': dx=0.1 elif letra =='A': dx=-0.1 elif letra ==' ': dy=0.1 elif letra =='Z': dy=-0.1 elif letra =='R': alpha+=1 glm.rotate(mat,alpha,0,1,0) cube['u_model'] = mat elif letra =='Q': alpha-=1 glm.rotate(mat,alpha,0,1,0) cube['u_model'] = mat glm.translate(mat, dx,dy,dz) view = cube['u_view'].reshape(4, 4) x,y,z = cube["u_light_position"] print('[',x,'],[',y,'],[',z,']') cube["u_light_position"] = x+dx,y+dy,z+dz cube['u_normal'] = np.array(np.matrix(np.dot(view, mat)).I.T) sleep(0.01)
def on_mouse_drag(self, x, y, dx, dy, button): width = self._width height = self._height x = (x*2.0 - width)/width dx = (2.*dx)/width y = (height - y*2.0)/height dy = -(2.*dy)/height if button == 2: # Left click self["view"] = glm.translate(self._view, dx, dy, 0) elif button == 8: # Right click self._trackball.drag_to(x,y,dx,dy) self["model"] = self._trackball.model
def get_key_point_transform(self, position, caller): """ From position to transformation matrix Apply corresponding scale first :param position: len 3 np.array of the new positions to be updated :param caller: caller name, defined in self.component_names """ if caller == "arm": return glm.translation(*position) else: return glm.translate( glm.scale(np.eye(4, dtype=np.float32), self.finger_scale, self.finger_scale, self.finger_scale), *position)
def on_key_press(key, modifiers): global phi, theta if key == app.window.key.UP: glm.translate(view, 0, 0, 0.1) program['u_view'] = view elif key == app.window.key.DOWN: glm.translate(view, 0, 0, -0.1) program['u_view'] = view elif key == app.window.key.RIGHT: glm.translate(view, -0.1, 0, 0) program['u_view'] = view elif key == app.window.key.LEFT: glm.translate(view, 0.1, 0, 0) program['u_view'] = view
def __init__(self, *args, **kwargs): """ Initialize the transform. """ code = library.get("transforms/trackball.glsl") Transform.__init__( self, code, *args, **kwargs ) self._width = 1 self._height = 1 # self.view_xyz = np.asarray( [ 2, 2, 0.5 ] ) # camera xyz # self.view_hpr = np.asarray( [ 187, 0, 0 ] ) # camera heading, pitch, roll (degrees) # self.view_xyz = np.asarray( [ 0.5, 0.25, 6.0 ] ) # camera xyz # self.view_hpr = np.asarray( [ 270, -22.5, 0 ] ) # camera heading, pitch, roll (degrees) self.view_xyz = np.asarray( [ 0.0, 0.0, 1.0 ] ) # camera xyz self.view_hpr = np.asarray( [ 0.0, 0.0, 0.0 ] ) # camera heading, pitch, roll (degrees) self._model = np.eye( 4, dtype=np.float32 ) self._projection = np.eye( 4, dtype=np.float32 ) self._view = np.eye( 4, dtype=np.float32 ) glm.translate( self._model, 0, 0, -1 )
def init(self): gl.glEnable(gl.GL_DEPTH_TEST) for e in self.entities: draw = e.draw view = np.eye(4, dtype=np.float32) glm.translate(view, 0, 0, -20) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) p = gloo.Program(ge.vertex_shaders['v1'], ge.fragment_shaders['f1']) p['u_view'] = view p['u_projection'] = projection p['u_model'] = model p.bind(draw.vertex_buffer) draw.program_shader = p if draw.vertex_buffer is None: draw.set_vertex(draw.vertex) if draw.index_buffer is None: draw.set_index(draw['index']) if self.window is not None: draw.set_projection(self.window.width, self.window.height) draw.set_color(draw.color)
def __init__(self, window_width=1024, window_height=1024, degree=0): self.programs = [] window = app.Window(window_width, window_height, color=(0, 0, 0, 1)) framebuffer = np.zeros((window.height, window.width * 3), dtype=np.uint8) self.deg_x, self.deg_y, self.mov_x, self.mov_y, self.size, self.zoom, self.radius = 0, 0, 0, 0, 1, -200, 200 self.u_model, self.u_view, self.u_projection = np.eye(4, dtype=np.float32), np.eye(4, dtype=np.float32), np.eye( 4, dtype=np.float32) u_view = np.eye(4, dtype=np.float32) glm.rotate(u_view, -90, 1, 0, 0) #glm.rotate(u_view, -70, 1, 0, 0) glm.rotate(u_view, degree + 270, 0, 1, 0) glm.translate(u_view, 0, 0, 0) #(0, 0, -125) self.u_view = u_view self.demo_dt = 0 self.scIdx = 0 @window.event def on_draw(dt): window.clear() demo_idx = 0 for program_object in self.programs: program = program_object.program model = matrix_model(np.copy(program_object.u_model)) #self.deg_x += dt*20 #self.deg_y += dt*40 self.demo_dt += dt/5 demo_idx += 1 ''' if self.demo_dt > 2: if demo_idx == 1: if self.demo_dt > 2.4: if program['alpha'] <= 0.1: continue else: program['alpha'] -= 0.01 elif demo_idx == 2: if self.demo_dt > 2.8: program['alpha'] += 0.01 ''' program['u_model'] = np.dot(model, self.u_model) program['u_view'] = self.u_view program['u_projection'] = self.u_projection if program_object.draw_mode == gl.GL_TRIANGLES: program.draw(program_object.draw_mode, program_object.face) elif program_object.draw_mode == gl.GL_LINES and program_object.name == 'ProgramSFM3DRegion': gl.glDisable(gl.GL_POLYGON_OFFSET_FILL) gl.glEnable(gl.GL_BLEND) gl.glDepthMask(gl.GL_FALSE) program.draw(program_object.draw_mode, program_object.O) gl.glDepthMask(gl.GL_TRUE) else: program.draw(program_object.draw_mode) @window.event def on_resize(width, height): ratio = width / float(height) self.u_projection = glm.perspective(64.0, ratio, 1, 10000.0) @window.event def on_init(): gl.glEnable(gl.GL_DEPTH_TEST) @window.event def on_mouse_scroll(x, y, dx, dy): if self.size + dy * 0.1 < 0.1: self.size = 0.1 else: # self.size += dy * 0.1 # self.zoom += dy*1 self.u_view = glm.translate(self.u_view , 0, 0, dy) @window.event def on_mouse_drag(x, y, dx, dy, button): if button == 2: self.deg_y += dy # degrees self.deg_x += dx # degrees elif button == 8: self.mov_y += dy/10 # degrees self.mov_x += dx/10 # degrees @window.event def on_key_press(symbol, modifiers): """ :param symbol: :param modifiers: :return: """ ''' if symbol == 88: # x self.view_orth_vector = np.array([self.radius, 0, 0]) self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1], self.view_orth_vector[2]) elif symbol == 89: # y self.view_orth_vector = np.array([0, self.radius, 0]) self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1], self.view_orth_vector[2]) elif symbol == 90: # z self.view_orth_vector = np.array([0, 0, self.radius]) self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1], self.view_orth_vector[2]) elif symbol == 70: # f self.view_orth_vector = -self.view_orth_vector self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1], self.view_orth_vector[2]) elif symbol == 80: # p gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer) png.from_array(framebuffer, 'RGB').save('screenshot.png') print('Key pressed (symbol=%s, modifiers=%s)' % (symbol, modifiers)) # self.program['color_sel'] = 1 - self.program['color_sel'] ''' #print(symbol) if symbol == 67: # c --> change color for program_object in self.programs: if program_object.name == 'ProgramSFM3DRegion': program_object.program['color_sel'] = 1 - program_object.program['color_sel'] elif symbol == 65: # a --> align sfm to google for program_object in self.programs: if program_object.name == 'ProgramSFM3DRegion' or program_object.name == 'programTrajectory': program_object.align_flip() elif symbol == 73: # i --> inverse google according anchor for program_object in self.programs: if program_object.name == 'ProgramSV3DRegion': program_object.apply_anchor_flip() elif symbol == 89: # y --> rotate google according anchor yaw for program_object in self.programs: if program_object.name == 'ProgramSV3DRegion': program_object.apply_yaw_flip() elif symbol == 80: # p --> print scrren gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer) #png.from_array(framebuffer, 'RGB').save('screenshot{}.png'.format(self.scIdx)) my_texture = np.reshape(framebuffer, (window.height, window.width, 3)) # Some unknown reason # The buffer didn't match what I see in the window my_texture = np.flipud(my_texture) scipy.misc.imsave('yolo.png', my_texture) self.scIdx += 1 def matrix_model(model): glm.scale(model, self.size, self.size, self.size) glm.rotate(model, self.deg_y, 1, 0, 0) glm.rotate(model, self.deg_x, 0, 0, 1) glm.translate(model, self.mov_x, -self.mov_y, 0) # model[3,3] = 1 return model
fovy = np.minimum(np.maximum(fovy*(1+dy/100), 10.0), 179.0) program['projection'] = glm.perspective(fovy, window.width/float(window.height), 1.0, 100.0) @window.event def on_init(): gl.glEnable(gl.GL_DEPTH_TEST) gl.glDisable(gl.GL_BLEND) program = gloo.Program(vertex, fragment) program.bind(V) view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) glm.translate(view, 0, 0, -3) program['texture'] = data.get("checkerboard") program['model'] = model program['view'] = view program['grid'] = Grid("pos", "index") program['grid']["rows"] = rows program['grid']["cols"] = cols program['clip'] = Clip("v_index") program['clip']["rows"] = rows program['clip']["cols"] = cols fovy = 30 phi, theta = 30, 20 app.run()
def offset_position(self, ecef): glm.translate(self.u_model, ecef[1], ecef[2], ecef[0])
shapes = [ primitives.plane(1.5), primitives.cube(1.5), primitives.sphere(), primitives.cubesphere(), primitives.cylinder(), primitives.torus(), primitives.cone(), primitives.pyramid(), primitives.teapot() ] vertices, indices = shapes[index] program = gloo.Program(vertex, fragment) program.bind(vertices) view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) glm.translate(view, 0, 0, -5) program['model'] = model program['view'] = view program['normal'] = np.array(np.matrix(np.dot(view, model)).I.T) program['texture'] = data.checkerboard() program["light1_position"] = 3, 0, 0+5 program["light2_position"] = 0, 3, 0+5 program["light3_position"] = -3, -3, +5 program["light1_color"] = 1, 0, 0 program["light2_color"] = 0, 1, 0 program["light3_color"] = 0, 0, 1 phi, theta = 0, 0 app.run()