Exemple #1
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive', size=(W, H))

        self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)

        # Set uniform and attribute
        self.program['a_id'] = gloo.VertexBuffer(a_id)
        self.program['a_position'] = gloo.VertexBuffer(a_position)

        self.translate = 5
        self.view = translate((0, 0, -self.translate), dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)

        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
        self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
                                      1.0, 1000.0)
        self.program['u_projection'] = self.projection

        self.program['u_model'] = self.model
        self.program['u_view'] = self.view

        self.theta = 0
        self.phi = 0

        self.context.set_clear_color('white')
        self.context.set_state('translucent')

        self.timer = app.Timer('auto', connect=self.on_timer)

        self.show()
Exemple #2
0
    def activate_zoom(self):

        gloo.set_viewport(0, 0, *self.physical_size)
        projection = perspective(45.0, self.size[0] / float(self.size[1]), 1.0,
                                 10000.0)
        self.program['projection'] = projection
        self.update()
def test_transforms():
    """Test basic transforms"""
    xfm = np.random.randn(4, 4).astype(np.float32)

    # Do a series of rotations that should end up into the same orientation
    # again, to ensure the order of computation is all correct
    # i.e. if rotated would return the transposed matrix this would not work
    # out (the translation part would be incorrect)
    new_xfm = xfm.dot(rotate(180, (1, 0, 0)).dot(rotate(-90, (0, 1, 0))))
    new_xfm = new_xfm.dot(rotate(90, (0, 0, 1)).dot(rotate(90, (0, 1, 0))))
    new_xfm = new_xfm.dot(rotate(90, (1, 0, 0)))
    assert_allclose(xfm, new_xfm)

    new_xfm = translate((1, -1, 1)).dot(translate((-1, 1, -1))).dot(xfm)
    assert_allclose(xfm, new_xfm)

    new_xfm = scale((1, 2, 3)).dot(scale((1, 1. / 2., 1. / 3.))).dot(xfm)
    assert_allclose(xfm, new_xfm)

    # These could be more complex...
    xfm = ortho(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = frustum(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = perspective(1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))
Exemple #4
0
    def __init__(self, size=(1600, 900), no_distort=False):
        '''Distorter object: Applies distortion to Contexts and drawables

        - size (X, Y): Size of monitor
        - distortion (Bool): Apply distortion or not?
        '''
        self.size = size
        self.left_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3,))
        self.right_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3,))
        
        self.left_eye = gloo.FrameBuffer(self.left_eye_tex, gloo.RenderBuffer(self.size))
        self.right_eye = gloo.FrameBuffer(self.right_eye_tex, gloo.RenderBuffer(self.size))

        self.left_eye_program, self.left_eye_indices = Mesh.make_eye(self.left_eye_tex, 'left')
        self.right_eye_program, self.right_eye_indices = Mesh.make_eye(self.right_eye_tex, 'right')

        self.IPD = 0.0647 # Interpupilary distance in m
        # Male: 64.7 mm
        # Female: 62.3 mm

        self.L_projection = parameters.projection_left.T
        self.R_projection = parameters.projection_right.T

        self.no_distort = no_distort
        if self.no_distort:
            self.projection = perspective(30.0, 1920 / float(1080), 2.0, 10.0)
            self.draw = self.draw_no_distortion
        else:

            self.draw = self.draw_distortion
Exemple #5
0
def test_transforms():
    """Test basic transforms"""
    xfm = np.random.randn(4, 4).astype(np.float32)

    for rot in [xrotate, yrotate, zrotate]:
        new_xfm = rot(rot(xfm, 90), -90)
        assert_allclose(xfm, new_xfm)

    new_xfm = rotate(rotate(xfm, 90, 1, 0, 0), 90, -1, 0, 0)
    assert_allclose(xfm, new_xfm)

    new_xfm = translate(translate(xfm, 1, -1), 1, -1, 1)
    assert_allclose(xfm, new_xfm)

    new_xfm = scale(scale(xfm, 1, 2, 3), 1, 1. / 2., 1. / 3.)
    assert_allclose(xfm, new_xfm)

    # These could be more complex...
    xfm = ortho(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = frustum(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = perspective(1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))
    def __init__(self, coordinate, color, radius, W, H):
        visuals.Visual.__init__(self, vertex, fragment)

        self.size = W, H
        #Camera settings
        self.translate = 120
        self.view = translate((0, 0, -self.translate), dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)
        self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
                                      1.0, 1000.0)

        self.shared_program.vert['model'] = self.model
        self.shared_program.vert['view'] = self.view
        self.shared_program.vert['projection'] = self.projection
        self.shared_program.frag['projection'] = self.projection

        self.shared_program.vert['light_position'] = 0., 0., 2.
        self.shared_program.frag['light_spec_position'] = -5., 5., -5.

        self.shared_program.vert['position'] = coordinate
        self.shared_program.vert['radius'] = radius
        self.shared_program.frag['radius'] = radius
        self.shared_program.frag['color'] = color

        self._draw_mode = 'points'
Exemple #7
0
    def __init__(self):
        app.Canvas.__init__(self,
                            size=(1024, 1024),
                            title='Skybox example',
                            keys='interactive')

        self.cubeSize = 10
        self.pressed = False
        self.azimuth = pi / 2.0
        self.elevation = pi / 2.0
        self.distanceMin = 1
        self.distanceMax = 50
        self.distance = 30
        self.sensitivity = 5.0
        self.view = getView(self.azimuth, self.elevation, self.distance)
        self.model = np.eye(4, dtype=np.float32)
        self.projection = np.eye(4, dtype=np.float32)

        self.program = gloo.Program(vertex_shader, fragment_shader, count=24)
        self.program['a_position'] = faces * self.cubeSize
        self.program['a_texcoord'] = faces
        self.program['a_texture'] = gloo.TextureCube(texture,
                                                     interpolation='linear')
        self.program['u_model'] = self.model
        self.program['u_view'] = self.view
        gloo.set_viewport(0, 0, *self.physical_size)
        self.projection = perspective(60.0, self.size[0] / float(self.size[1]),
                                      1.0, 100.0)
        self.program['u_projection'] = self.projection

        gl.glEnable(gl.GL_DEPTH_TEST)
        gloo.set_clear_color('black')
        self.show()
Exemple #8
0
 def toggle_projection(self, event=None):
     """Toggle between perspective and orthonormal projection modes."""
     self.perspective = not self.perspective
     if self.perspective:
         self.volume_renderer.set_vol_projection(perspective(60, 1., 100, 0))
     else:
         self.volume_renderer.set_vol_projection(ortho(-1, 1, -1, 1, -1000, 1000))
Exemple #9
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive', size=(800, 600))

        self.vertices, self.filled, self.outline = cube()
        self.filled_buf = gloo.IndexBuffer(self.filled)
        self.outline_buf = gloo.IndexBuffer(self.outline)

        self.program = gloo.Program(vert, frag)
        self.program.bind(gloo.VertexBuffer(self.vertices))

        self.view = translate((0, 0, -5))
        self.model = np.eye(4, dtype=np.float32)

        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
        self.projection = perspective(45.0, self.size[0] /
                                      float(self.size[1]), 2.0, 10.0)

        self.program['u_projection'] = self.projection

        self.program['u_model'] = self.model
        self.program['u_view'] = self.view

        self.theta = 0
        self.phi = 0

        gloo.set_clear_color('white')
        gloo.set_state('opaque')
        gloo.set_polygon_offset(1, 1)

        self._timer = app.Timer('auto', connect=self.on_timer, start=True)

        self.show()
Exemple #10
0
    def __init__(self):
        app.Canvas.__init__(self, size=(1024, 1024), title='Skybox example',
                            keys='interactive')

        self.cubeSize = 10
        self.pressed = False
        self.azimuth = pi / 2.0
        self.elevation = pi / 2.0
        self.distanceMin = 1
        self.distanceMax = 50
        self.distance = 30
        self.sensitivity = 5.0
        self.view = getView(self.azimuth, self.elevation, self.distance)
        self.model = np.eye(4, dtype=np.float32)
        self.projection = np.eye(4, dtype=np.float32)

        self.program = gloo.Program(vertex_shader, fragment_shader, count=24)
        self.program['a_position'] = faces*self.cubeSize
        self.program['a_texcoord'] = faces
        self.program['a_texture'] = gloo.TextureCube(texture, interpolation='linear')
        self.program['u_model'] = self.model
        self.program['u_view'] = self.view
        gloo.set_viewport(0, 0, *self.physical_size)
        self.projection = perspective(60.0, self.size[0] /
                                      float(self.size[1]), 1.0, 100.0)
        self.program['u_projection'] = self.projection

        gl.glEnable(gl.GL_DEPTH_TEST)
        gloo.set_clear_color('black')
        self.show()
Exemple #11
0
    def apply_zoom(self):
        """Determine the projection of the canvas"""

        width, height = self.physical_size
        gloo.set_viewport(0, 0, width, height)
        self.projection = perspective(95.0, width / float(height), 1.0, 400.0)
        self.program['u_projection'] = self.projection
Exemple #12
0
    def __init__(self, mesh, position=(0.0, 0.0, 0.0), orientation=None, color=(255., 0., 0., 255.0), faces=None,
                 shader_manager=None):
        '''Orientation must be a 4x4 rotation matrix'''
        self.position = np.array(position, dtype=np.float32)
        if orientation is None:
            self.orientation = np.eye(4)
        else:
            assert orientation.shape == (4, 4), "Orientation must be a 4x4 numpy array"
            self.orientation = orientation

        if len(color) == 3:
            color = color + (255,)
        self.color = np.array(color, dtype=np.float32) / 255.  # Normalize to [0, 1]

        self.program = gloo.Program(self._vertex_shader, self._fragment_shader)
        self.program.bind(mesh)
        self.faces = gloo.IndexBuffer(faces)

        self.model = np.eye(4, dtype=np.float32)
        self.model = self.model.dot(translate(self.position))
        self.view = np.eye(4, dtype=np.float32)

        self.projection = perspective(30.0, 800 / float(800), 2.0, 500.0)
        self.program['u_model'] = self.model
        self.program['u_view'] = self.view
        self.program['u_projection'] = self.projection
        self.program['u_color'] = self.color
        self.children = []
Exemple #13
0
    def __init__(self,
                 mesh,
                 position=(0.0, 0.0, 0.0),
                 orientation=None,
                 color=(255., 0., 0., 255.0),
                 faces=None,
                 shader_manager=None):
        '''Orientation must be a 4x4 rotation matrix'''
        self.position = np.array(position, dtype=np.float32)
        if orientation is None:
            self.orientation = np.eye(4)
        else:
            assert orientation.shape == (
                4, 4), "Orientation must be a 4x4 numpy array"
            self.orientation = orientation

        if len(color) == 3:
            color = color + (255, )
        self.color = np.array(color,
                              dtype=np.float32) / 255.  # Normalize to [0, 1]

        self.program = gloo.Program(self._vertex_shader, self._fragment_shader)
        self.program.bind(mesh)
        self.faces = gloo.IndexBuffer(faces)

        self.model = np.eye(4, dtype=np.float32)
        self.model = self.model.dot(translate(self.position))
        self.view = np.eye(4, dtype=np.float32)

        self.projection = perspective(30.0, 800 / float(800), 2.0, 500.0)
        self.program['u_model'] = self.model
        self.program['u_view'] = self.view
        self.program['u_projection'] = self.projection
        self.program['u_color'] = self.color
        self.children = []
Exemple #14
0
    def __init__(self, size=(1600, 900), no_distort=False):
        '''Distorter object: Applies distortion to Contexts and drawables

        - size (X, Y): Size of monitor
        - distortion (Bool): Apply distortion or not?
        '''
        self.size = size
        self.left_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3, ))
        self.right_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3, ))

        self.left_eye = gloo.FrameBuffer(self.left_eye_tex,
                                         gloo.RenderBuffer(self.size))
        self.right_eye = gloo.FrameBuffer(self.right_eye_tex,
                                          gloo.RenderBuffer(self.size))

        self.left_eye_program, self.left_eye_indices = Mesh.make_eye(
            self.left_eye_tex, 'left')
        self.right_eye_program, self.right_eye_indices = Mesh.make_eye(
            self.right_eye_tex, 'right')

        self.IPD = 0.0647  # Interpupilary distance in m
        # Male: 64.7 mm
        # Female: 62.3 mm

        self.L_projection = parameters.projection_left.T
        self.R_projection = parameters.projection_right.T

        self.no_distort = no_distort
        if self.no_distort:
            self.projection = perspective(30.0, 1920 / float(1080), 2.0, 10.0)
            self.draw = self.draw_no_distortion
        else:

            self.draw = self.draw_distortion
Exemple #15
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive', size=(800, 600))

        self.vertices, self.filled, self.outline = cube()
        self.filled_buf = gloo.IndexBuffer(self.filled)
        self.outline_buf = gloo.IndexBuffer(self.outline)

        self.program = gloo.Program(vert, frag)
        self.program.bind(gloo.VertexBuffer(self.vertices))

        self.view = translate((0, 0, -5))
        self.model = np.eye(4, dtype=np.float32)

        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
        self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
                                      2.0, 10.0)

        self.program['u_projection'] = self.projection

        self.program['u_model'] = self.model
        self.program['u_view'] = self.view

        self.theta = 0
        self.phi = 0
        self.transparency = 1
        gloo.set_clear_color((0, 0, 0), 0.1)
        gloo.set_state('opaque')
        gloo.set_polygon_offset(1, 1)

        #self._timer = app.Timer('auto', connect=self.on_timer, start=True)   #Siempre poner un timer asi se pone bien la funcion update!! solo en pyglet, en pyqt5 funciona joya!!!
        self._monitor = MidiMonitor(connect=self.on_midi)

        self.show()
Exemple #16
0
 def apply_zoom(self):
     gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
     self.projection = perspective(self.fov,
                                   self.size[0] / float(self.size[1]), 0.01,
                                   10000.0)
     for k, prog in self.GL_progs.items():
         prog['u_projection'] = self.projection
Exemple #17
0
    def on_initialize(self, event):
        # create a new shader program
        self.program = gloo.Program(VERT_SHADER, FRAG_SHADER,
                                    count=len(galaxy))

        # load the star texture
        self.texture = gloo.Texture2D(load_galaxy_star_image(),
                                      interpolation='linear')
        self.program['u_texture'] = self.texture

        # construct the model, view and projection matrices
        self.view = np.eye(4, dtype=np.float32)
        transforms.translate(self.view, 0, 0, -5)
        self.program['u_view'] = self.view

        self.model = np.eye(4, dtype=np.float32)
        self.program['u_model'] = self.model

        self.program['u_colormap'] = colors

        self.projection = perspective(45.0, self.width / float(self.height),
                                      1.0, 1000.0)
        self.program['u_projection'] = self.projection

        # start the galaxy to some decent point in the future
        galaxy.update(100000)
        data = self.__create_galaxy_vertex_data()

        # setup the VBO once the galaxy vertex data has been setup
        # bind the VBO for the first time
        self.data_vbo = gloo.VertexBuffer(data)
        self.program.bind(self.data_vbo)

        # setup blending
        self.__setup_blending_mode()
Exemple #18
0
    def apply_resize(self,viewpoint):
        gloo.set_viewport(*viewpoint)
        self.projection = perspective(42.74, self.size[0] /
                                      float(self.size[1]), 1.0, 1000.0)
        # self.projection = ortho(left=-1,right=1,bottom=-1,top=1,znear=0.10,zfar=1000)

        self.program['u_projection'] = self.projection
Exemple #19
0
 def on_resize(self, event):
     # setup the new viewport
     gloo.set_viewport(0, 0, *event.physical_size)
     # recompute the projection matrix
     w, h = event.size
     self.projection = perspective(45.0, w / float(h), 1.0, 1000.0)
     self.program['u_projection'] = self.projection
Exemple #20
0
def test_transforms():
    """Test basic transforms"""
    xfm = np.random.randn(4, 4).astype(np.float32)

    # Do a series of rotations that should end up into the same orientation
    # again, to ensure the order of computation is all correct
    # i.e. if rotated would return the transposed matrix this would not work
    # out (the translation part would be incorrect)
    new_xfm = xfm.dot(rotate(180, (1, 0, 0)).dot(rotate(-90, (0, 1, 0))))
    new_xfm = new_xfm.dot(rotate(90, (0, 0, 1)).dot(rotate(90, (0, 1, 0))))
    new_xfm = new_xfm.dot(rotate(90, (1, 0, 0)))
    assert_allclose(xfm, new_xfm)

    new_xfm = translate((1, -1, 1)).dot(translate((-1, 1, -1))).dot(xfm)
    assert_allclose(xfm, new_xfm)

    new_xfm = scale((1, 2, 3)).dot(scale((1, 1. / 2., 1. / 3.))).dot(xfm)
    assert_allclose(xfm, new_xfm)

    # These could be more complex...
    xfm = ortho(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = frustum(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = perspective(1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))
Exemple #21
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive', size=(W, H))

        self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)

        # Set uniform and attribute
        self.program['a_id'] = gloo.VertexBuffer(a_id)
        self.program['a_position'] = gloo.VertexBuffer(a_position)

        self.translate = 5
        self.view = translate((0, 0, -self.translate), dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)

        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
        self.projection = perspective(45.0, self.size[0] /
                                      float(self.size[1]), 1.0, 1000.0)
        self.program['u_projection'] = self.projection

        self.program['u_model'] = self.model
        self.program['u_view'] = self.view

        self.theta = 0
        self.phi = 0

        self.context.set_clear_color('white')
        self.context.set_state('translucent')

        self.timer = app.Timer('auto', connect=self.on_timer)

        self.show()
Exemple #22
0
    def on_resize(self, event):
        gloo.set_viewport(0, 0, event.physical_size[0], event.physical_size[1])
        self.projection = perspective(45.0,
                                      event.size[0] / float(event.size[1]),
                                      1.0, 100.0)

        self.program['u_projection'] = self.projection
Exemple #23
0
 def on_resize(self, event):
     width, height = event.size
     self.size = event.size
     gloo.set_viewport(0, 0, width, height)
     self.aspect = width / float(height)
     self.projection = perspective(45.0, width / float(height), 2, 10.0)
     self.program_quad['u_projection'] = self.projection
def test_transforms():
    """Test basic transforms"""
    xfm = np.random.randn(4, 4).astype(np.float32)

    for rot in [xrotate, yrotate, zrotate]:
        new_xfm = rot(rot(xfm, 90), -90)
        assert_allclose(xfm, new_xfm)

    new_xfm = rotate(rotate(xfm, 90, 1, 0, 0), 90, -1, 0, 0)
    assert_allclose(xfm, new_xfm)

    new_xfm = translate(translate(xfm, 1, -1), 1, -1, 1)
    assert_allclose(xfm, new_xfm)

    new_xfm = scale(scale(xfm, 1, 2, 3), 1, 1. / 2., 1. / 3.)
    assert_allclose(xfm, new_xfm)

    # These could be more complex...
    xfm = ortho(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = frustum(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = perspective(1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))
Exemple #25
0
 def apply_zoom(self):
     gloo.set_viewport(0, 0, self.canvas.physical_size[0],
                       self.canvas.physical_size[1])
     self.projection = transforms.perspective(
         90.0, self.canvas.size[0] / float(self.canvas.size[1]), 1.0,
         1000.0)
     self.transform_uniforms['u_projection'] = self.projection
Exemple #26
0
    def __init__(self):

        # setup initial width, height

        app.Canvas.__init__(self, keys='interactive', size=(800, 600))

        # create a new shader program

        self.program = gloo.Program(VERT_SHADER,
                                    FRAG_SHADER,
                                    count=len(galaxy))

        # load the star texture

        self.texture = gloo.Texture2D(load_galaxy_star_image(),
                                      interpolation='linear')

        self.program['u_texture'] = self.texture

        # construct the model, view and projection matrices

        self.view = transforms.translate((0, 0, -5))

        self.program['u_view'] = self.view

        self.model = np.eye(4, dtype=np.float32)

        self.program['u_model'] = self.model

        self.program['u_colormap'] = colors

        w, h = self.size

        self.projection = perspective(45.0, w / float(h), 1.0, 1000.0)

        self.program['u_projection'] = self.projection

        # start the galaxy to some decent point in the future

        galaxy.update(100000)

        data = self.__create_galaxy_vertex_data()

        # setup the VBO once the galaxy vertex data has been setup

        # bind the VBO for the first time

        self.data_vbo = gloo.VertexBuffer(data)

        self.program.bind(self.data_vbo)

        # setup blending

        gloo.set_state(clear_color=(0.0, 0.0, 0.03, 1.0),
                       depth_test=False,
                       blend=True,
                       blend_func=('src_alpha', 'one'))

        self._timer = app.Timer('auto', connect=self.update, start=True)
 def on_resize(self, event):
     width, height = event.size
     gloo.set_viewport(0, 0, width, height)
     self.projection = perspective(45.0, width / float(height), 1.0, 1000.0)
     self.program_data['u_projection'] = self.projection
     self.program_axis['u_projection'] = self.projection
     self.program_plane['u_projection'] = self.projection
     self.update()
Exemple #28
0
 def on_resize(self, event):
     self.resolution = event.physical_size
     gloo.set_viewport(0, 0, self.resolution[0], self.resolution[1])
     self.projection = perspective(45.0,
                                   event.size[0] / float(event.size[1]),
                                   1.0, 1000.0)
     for program in self.programs:
         program['u_projection'] = self.projection
Exemple #29
0
 def on_resize(self, event):
     self.width, self.height = event.size
     # setup the new viewport
     gloo.set_viewport(0, 0, self.width, self.height)
     # recompute the projection matrix
     self.projection = perspective(45.0, self.width / float(self.height),
                                   1.0, 1000.0)
     self.program['u_projection'] = self.projection
Exemple #30
0
 def apply_zoom(self):
     width, height = self.physical_size
     vp = (0, 0, width, height)
     gloo.set_viewport(vp)
     self.projection = perspective(45.0, width / float(height), 1.0,
                                   1000.0)
     self.program['u_projection'] = self.projection
     self.text.transforms.configure(canvas=self, viewport=vp)
Exemple #31
0
 def recalc_projection(self):
   self.projection = perspective(
       25.0, 
       self.width / float(self.height), 
       1.0, 
       50.0+self.zoom)
   self.fog_near = self.zoom
   self.fog_far = 20.0 + self.zoom
Exemple #32
0
 def on_resize(self, event):
     # setup the new viewport
     gloo.set_viewport(0, 0, *event.physical_size)
     # recompute the projection matrix
     w, h = event.size
     self.projection = perspective(45.0, w / float(h),
                                   1.0, 1000.0)
     self.program['u_projection'] = self.projection
Exemple #33
0
 def on_resize(self, event):
     width, height = event.size
     gloo.set_viewport(0, 0, width, height)
     self.projection = perspective(45.0, width / float(height), 1.0, 1000.0)
     self.program_data['u_projection'] = self.projection
     self.program_axis['u_projection'] = self.projection
     self.program_plane['u_projection'] = self.projection
     self.update()
Exemple #34
0
 def on_resize(self, event):
     self.width, self.height = event.size
     # setup the new viewport
     gloo.set_viewport(0, 0, self.width, self.height)
     # recompute the projection matrix
     self.projection = perspective(45.0, self.width / float(self.height),
                                   1.0, 1000.0)
     self.program['u_projection'] = self.projection
Exemple #35
0
 def on_resize(self, event):
     width, height = event.size
     self.size = event.size
     gloo.set_viewport(0, 0, width, height)
     self.aspect = width / float(height)
     self.projection = perspective(45.0, width / float(height), 2,
                                   10.0)
     self.program_quad['u_projection'] = self.projection
 def on_resize(self, event):
     width, height = event.size
     self.size = event.size
     gloo.set_viewport(0, 0, width, height)
     self.aspect = width / float(height)
     self.projection = perspective(self.fovy, width / float(height), 1.0,
                                   self.zfar)
     self.program['u_projection'] = self.projection
Exemple #37
0
 def on_resize(self, event):
     width, height = event.size
     self.size = event.size
     gloo.set_viewport(0, 0, width, height)
     self.aspect = width / float(height)
     self.projection = perspective(self.fovy, width / float(height), 1.0,
                                   self.zfar)
     self.program['u_projection'] = self.projection
Exemple #38
0
 def on_resize(self, event):
     """
     We create a callback function called when the window is being resized.
     Updating the OpenGL viewport lets us ensure that
     Vispy uses the entire canvas.
     """
     gloo.set_viewport(0, 0, *event.physical_size)
     ratio = event.physical_size[0] / float(event.physical_size[1])
     self.program['u_projection'] = perspective(45.0, ratio, 2.0, 10.0)
Exemple #39
0
 def update_scene(self):
     scale_matrix = scale([1, 1, 1])
     rotation_matrix = rotate(self.rotation, [0, 1, 0])
     translation_matrix = translate([0.4, 0, -4])
     model_matrix = scale_matrix @ rotation_matrix @ translation_matrix
     self.program['model_matrix'] = model_matrix
     self.program['normal_matrix'] = np.linalg.inv(model_matrix)
     self.program['view_matrix'] = translate([0, 0, 0])
     self.program['projection_matrix'] = perspective(45, 1.66, 1., 100.)
Exemple #40
0
 def toggle_projection(self, event=None):
     """Toggle between perspective and orthonormal projection modes."""
     self.perspective = not self.perspective
     if self.perspective:
         self.volume_renderer.set_vol_projection(perspective(60, 1., 100, 0))
         self.volume_renderer.uniform_changes['projection'] = 'perspective'
     else:
         self.volume_renderer.set_vol_projection(ortho(-1, 1, -1, 1, -1000, 1000))
         self.volume_renderer.uniform_changes['projection'] = 'orthographic'
Exemple #41
0
 def on_resize(self, event):
     """
     We create a callback function called when the window is being resized.
     Updating the OpenGL viewport lets us ensure that
     Vispy uses the entire canvas.
     """
     gloo.set_viewport(0, 0, *event.physical_size)
     ratio = event.physical_size[0] / float(event.physical_size[1])
     self.program['u_projection'] = perspective(45.0, ratio, 2.0, 10.0)
Exemple #42
0
    def resetProjection(self):
        # calculate projection
        gloo.set_viewport(0, 0, *self.physical_size)
        aspect = self.size[0] / float(self.size[1])
        self._projection = perspective(self.fov, aspect, self.nearDistance, self.farDistance)
        self.program['projection'] = self._projection

        # calculate projection for the orientation indicator in the lower left
        orthoScale = 1/500
        orthoProjection = glm.ortho( -self.size[0]*orthoScale , self.size[0]*orthoScale, -self.size[1]*orthoScale, self.size[1]*orthoScale)
        self._oriProjection = glm.translate(orthoProjection,glm.vec3(-self.size[0]*orthoScale+0.28,-self.size[1]*orthoScale+0.28,0))
Exemple #43
0
    def __init__(self):
        app.Canvas.__init__(self, keys='interactive', size=(800, 600))

        rospy.init_node('imu_visualizer')
        #         assert_node_alive('torso_arduino')

        rospy.Subscriber('imu/data_raw', Imu, self.on_imu)

        # Cleanup when termniating the node
        rospy.on_shutdown(self.shutdown)

        self.vertices, self.filled, self.outline = cube()
        self.filled_buf = gloo.IndexBuffer(self.filled)
        self.outline_buf = gloo.IndexBuffer(self.outline)

        self.program = gloo.Program(vert, frag)
        self.program.bind(gloo.VertexBuffer(self.vertices))

        self.view = translate((0, 0, -5))
        self.model = np.eye(4, dtype=np.float32)

        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
        self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
                                      2.0, 10.0)

        self.program['u_projection'] = self.projection
        self.program['u_model'] = self.model
        self.program['u_view'] = self.view

        self.yaw = 0  # yaw
        self.roll = 0  # roll
        self.pitch = 0  # pitch

        gloo.set_clear_color('white')
        #         gloo.set_clear_color('black')
        gloo.set_state('opaque')
        gloo.set_polygon_offset(1, 1)

        self.first = True
        self.yaw0 = None

        self._timer = app.Timer('auto', connect=self.on_timer, start=True)

        self.show()

        app.run()

        rospy.signal_shutdown("Shutting done.")
        self.shutdown()
        print('Node shutdown.')
Exemple #44
0
 def on_key_press(self, event):
     if event.text == 'j':
         self.th += self.delta
     elif event.text == 'k':
         self.th -= self.delta
     elif event.text == 'h':
         self.ph -= self.delta
     elif event.text == 'l':
         self.ph += self.delta
     elif event.text == 'n':
         width, height = self.size
         self.fov += self.delta/2
         self.fov = np.clip(self.fov, 10., 90.)
         self.proj = perspective(self.fov, np.divide(width, height),
                                 1., 100.)
     elif event.text == 'p':
         width, height = self.size
         self.fov -= self.delta/2
         self.fov = np.clip(self.fov, 10., 90.)
         self.proj = perspective(self.fov, np.divide(width, height),
                                 1., 100.)
     self.view = lookat(self.th, self.ph)
     self.update()
Exemple #45
0
    def __init__(self,
                 positions,
                 data_path,
                 atoms_number=50,
                 resolution=(800, 600)):
        self.data_path = data_path
        self.resolution = resolution
        app.Canvas.__init__(self, keys='interactive', size=self.resolution)
        self.delta_pos = positions[:1].mean()
        self.positions = positions  # - self.delta_pos
        self.atoms_number = atoms_number

        self.mouse_press_point = 0, 0
        self.mouse_press = False
        self.theta = 0
        self.phi = 0
        self.delta_theta = 0
        self.delta_phi = 0
        self.animation_step = 25000  # max 474984

        self.translate = 50
        self.view = translate((0, 0, -self.translate), dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)
        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
        self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
                                      1.0, 1000.0)

        self.alpha = np.array((0, 0, 0, 0)).astype(np.float32).reshape(1, 4)
        self.a_color = [
            np.append(np.random.rand(3), 1).astype(np.float32).reshape(1, 4)
            for _ in range(self.positions.shape[1])
        ]

        self.plot_lines = PlotLines(self)
        self.plot_points = PlotPoints(self)
        self.plot_itrium = PlotItrium(self)
        self.programs = [
            self.plot_lines.program, self.plot_points.program,
            self.plot_itrium.program
        ]

        self.context.set_clear_color('white')
        self.context.set_state('translucent')

        self.timer = app.Timer('auto', connect=self.on_timer)
        self.timer.start()

        self.show()
Exemple #46
0
  def __init__(self):
    app.Canvas.__init__(self, keys='interactive', size=(800, 600))

    dirname = path.join(path.abspath(path.curdir),'data')
    positions, faces, normals, texcoords = \
      read_mesh(load_data_file('cube.obj', directory=dirname))

    self.filled_buf = gloo.IndexBuffer(faces)

    if False:
      self.program = gloo.Program(VERT_TEX_CODE, FRAG_TEX_CODE)
      self.program['a_position'] = gloo.VertexBuffer(positions)
      self.program['a_texcoord'] = gloo.VertexBuffer(texcoords)
      self.program['u_texture'] = gloo.Texture2D(load_crate())
    else:
      self.program = gloo.Program(VERT_COLOR_CODE, FRAG_COLOR_CODE)
      self.program['a_position'] = gloo.VertexBuffer(positions)
      self.program['u_color'] = 1, 0, 0, 1

    self.view = translate((0, 0, -5))
    self.model = np.eye(4, dtype=np.float32)

    gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
    self.projection = perspective(45.0, self.size[0] /
                                  float(self.size[1]), 2.0, 10.0)

    self.program['u_projection'] = self.projection

    self.program['u_model'] = self.model
    self.program['u_view'] = self.view

    self.theta = 0
    self.phi = 0

    gloo.set_clear_color('gray')
    gloo.set_state('opaque')
    gloo.set_polygon_offset(1, 1)

    self._timer = app.Timer('auto', connect=self.on_timer, start=True)

    self.show()
Exemple #47
0
    def __init__(self):
        # setup initial width, height
        app.Canvas.__init__(self, keys='interactive', size=(800, 600))

        # create a new shader program
        self.program = gloo.Program(VERT_SHADER, FRAG_SHADER,
                                    count=len(galaxy))

        # load the star texture
        self.texture = gloo.Texture2D(load_galaxy_star_image(),
                                      interpolation='linear')
        self.program['u_texture'] = self.texture

        # construct the model, view and projection matrices
        self.view = transforms.translate((0, 0, -5))
        self.program['u_view'] = self.view

        self.model = np.eye(4, dtype=np.float32)
        self.program['u_model'] = self.model

        self.program['u_colormap'] = colors

        w, h = self.size
        self.projection = perspective(45.0, w / float(h), 1.0, 1000.0)
        self.program['u_projection'] = self.projection

        # start the galaxy to some decent point in the future
        galaxy.update(100000)
        data = self.__create_galaxy_vertex_data()

        # setup the VBO once the galaxy vertex data has been setup
        # bind the VBO for the first time
        self.data_vbo = gloo.VertexBuffer(data)
        self.program.bind(self.data_vbo)

        # setup blending
        gloo.set_state(clear_color=(0.0, 0.0, 0.03, 1.0),
                       depth_test=False, blend=True,
                       blend_func=('src_alpha', 'one'))

        self._timer = app.Timer('auto', connect=self.update, start=True)
Exemple #48
0
 def get_projection(self, viewbox):
     
     w, h = viewbox.resolution
     
     fov = self._fov
     aspect = 1.0
     fx = fy = 1.0 # todo: hard-coded
     
     # Calculate distance to center in order to have correct FoV and fy.
     if fov == 0:
         M = transforms.ortho(-0.5*fx, 0.5*fx, -0.5*fy, 0.5*fy, -10000, 10000)
         self._d = 0
     else:
         d = fy / (2 * math.tan(math.radians(fov)/2))
         val = math.sqrt(10000)  # math.sqrt(getDepthValue())
         znear, zfar = d/val, d*val
         M = transforms.perspective(fov, aspect, znear, zfar)
     
     # Translation and rotation is done by our 'transformation' parameter
     
     return M
 
     
	def __init__(self, mesh, vertexShader, fragShader):
		app.Canvas.__init__(self, keys='interactive', size=(1600,900))
		self.mesh = mesh
		self.data = mesh.buildBuffer()

		self.program = gloo.Program(vertexShader, fragShader)

		self.model = np.eye(4, dtype=np.float32)
		self.projection = perspective(45.0, self.size[0] /
                                      float(self.size[1]), 1.0, 1000.0)

		gloo.set_viewport(0, 0, self.size[0], self.size[1])

		self.camera = camera.Camera(np.array([0,0,-5], dtype = np.float32), np.array([0,0,0], dtype = np.float32), 45.0, self.size)

		self.view = self.camera.view

		self.program.bind(gloo.VertexBuffer(mesh.buildBuffer()))
		self.program['u_model'] = self.model
		self.program['u_view'] = self.view
		self.program['u_projection'] = self.projection

		self.program['u_lightPos'] = np.array([20, 20, -20], dtype = np.float32);
		self.program['u_lightColor'] = np.array([1, 1, 1], dtype = np.float32);

		gloo.set_depth_mask(True)
		gloo.set_blend_func('src_alpha', 'one_minus_src_alpha') 
		gloo.set_blend_equation('func_add')
		gloo.set_cull_face('back')
		gloo.set_front_face('cw')

		gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=True)

		self.show()

		self.theta = 0
		self.phi = 0
Exemple #50
0
 def apply_zoom(self):
     gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
     self.projection = perspective(45.0, self.size[0] /
                                   float(self.size[1]), 1.0, 1000.0)
     self.program['u_projection'] = self.projection
Exemple #51
0
    def __init__(self):
        app.Canvas.__init__(self, keys="interactive", size=(W, H))

        self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
        self.l_bb_center = []

        vbuffer = np.array(
            [
                [0.6459411621, 0.4028605652, 0.1],
                [0.6459389496, 0.4028595352, 0.1],
                [0.6459381104, 0.4028591156, 0.1],
                [0.6459369659, 0.4028584671, 0.1],
                [0.6459358978, 0.4028577423, 0.1],
                [0.6459277344, 0.4028533173, 0.1],
                [0.6459257507, 0.402852211, 0.1],
                [0.6459215546, 0.402849884, 0.1],
                [0.6459153748, 0.402846489, 0.1],
                [0.6459139252, 0.4028466415, 0.1],
                [0.6459128571, 0.4028461456, 0.1],
                [0.6459088135, 0.4028437805, 0.1],
                [0.6459063721, 0.4028423691, 0.1],
                [0.6459036255, 0.4028408813, 0.1],
                [0.6459024811, 0.4028401947, 0.1],
                [0.6459013367, 0.4028395844, 0.1],
                [0.6458982086, 0.402837944, 0.1],
                [0.6458907318, 0.4028339005, 0.1],
                [0.6458789825, 0.4028277206, 0.1],
                [0.645867157, 0.4028213882, 0.1],
                [0.6458557892, 0.402815094, 0.1],
                [0.6458435822, 0.4028086472, 0.1],
            ]
        ).astype(np.float32)

        arr_min = np.full(vbuffer.shape, vbuffer.min(axis=0))
        arr_max = np.full(vbuffer.shape, vbuffer.max(axis=0))

        arr_bounded = vbuffer - arr_min

        arr_bounded = arr_bounded * vbuffer.max(axis=0) * i_scale_factor

        arr_bounded = arr_bounded.astype(np.float32)
        print(arr_bounded)

        self.l_bb_center = (vbuffer.max(axis=0) - vbuffer.min(axis=0)) * i_scale_factor / 2.0

        print(self.l_bb_center)

        # Set uniform and attribute
        self.program["a_position"] = gloo.VertexBuffer(arr_bounded)

        self.translate = 5
        self.view = translate((-self.l_bb_center[0], -self.l_bb_center[1], -self.translate), dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)

        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
        self.projection = perspective(45.0, self.size[0] / float(self.size[1]), 1.0, 1000.0)

        # self.projection = ortho(-1, 1, -1, 1, -10, 10)
        self.program["u_projection"] = self.projection

        self.program["u_model"] = self.model
        self.program["u_view"] = self.view

        self.theta = 0
        self.phi = 0

        self.context.set_clear_color("white")
        self.context.set_state("translucent")

        self.timer = app.Timer("auto", connect=self.on_timer)

        self.show()
Exemple #52
0
 def on_resize(self, event):
     width, height = event.size
     gl.glViewport(0, 0, width, height)
     self.projection = perspective( 45.0, width/float(height), 1.0, 1000.0 )
     self.program['u_projection'] = self.projection
Exemple #53
0
 def on_resize(self, event):
     width, height = event.size
     gloo.set_viewport(0, 0, width, height)
     self.projection = perspective(25.0, width / float(height), 2.0, 100.0)
     self.program['u_projection'] = self.projection
Exemple #54
0
    def on_resize(self, event):
        gloo.set_viewport(0, 0, event.physical_size[0], event.physical_size[1])
        self.projection = perspective(45.0, event.size[0] / float(event.size[1]), 1.0, 1000.0)

        # self.projection = ortho(-1, 1, -1, 1, -10, 10)
        self.program["u_projection"] = self.projection
 def on_resize(self, event):
     width, height = event.size
     gloo.set_viewport(0, 0, width, height)
     far = SIZE*(NBLOCKS-2)
     self.projection = perspective(25.0, width / float(height), 1.0, far)
     self.program['u_projection'] = self.projection
Exemple #56
0
 def activate_zoom(self):
     gloo.set_viewport(0, 0, *self.physical_size)
     self.projection = perspective(60.0, self.size[0] /
                                   float(self.size[1]), 1.0, 100.0)
     self.program['u_projection'] = self.projection
Exemple #57
0
 def _set_projection(self, size):
     width, height = size
     set_viewport(0, 0, width, height)
     projection = perspective(30.0, width / float(height), 2.0, 10.0)
     self.cube['projection'] = projection
Exemple #58
0
 def on_resize(self, event):
     gloo.set_viewport(0, 0, event.physical_size[0], event.physical_size[1])
     self.projection = perspective(45.0, event.size[0] /
                                   float(event.size[1]), 2.0, 10.0)
     self.program['u_projection'] = self.projection
Exemple #59
0
 def on_resize(self, event):
     gloo.set_viewport(0, 0, *event.size)
     projection = perspective(45.0, event.size[0] / float(event.size[1]),
                              2.0, 10.0)
     self.program['projection'] = projection