コード例 #1
0
def main():    
    GLUT.glutInit(argv)
    GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)
    larguraTela = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
    alturaTela = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)
    larguraJanela = round(2 * larguraTela / 3)
    alturaJanela = round(2 * alturaTela / 3)
    GLUT.glutInitWindowSize(larguraJanela, alturaJanela)
    GLUT.glutInitWindowPosition(round((larguraTela - larguraJanela) / 2), round((alturaTela - alturaJanela) / 2))
    GLUT.glutCreateWindow(janela)
    GLUT.glutDisplayFunc(draw)
    load()
    GL.glEnable(GL.GL_MULTISAMPLE)
    GL.glEnable(GL.GL_DEPTH_TEST)
    GL.glEnable(GL.GL_TEXTURE_2D)
    GL.glClearColor(*corFundo)
    GL.glClearDepth(1.0)
    GL.glDepthFunc(GL.GL_LESS)
    GL.glShadeModel(GL.GL_SMOOTH)
    GL.glMatrixMode(GL.GL_PROJECTION)
    GLU.gluPerspective(-45, larguraJanela / alturaJanela, 0.1, 100.0)
    GL.glTranslatef(0.0, 0.0, -10)
    GL.glMatrixMode(GL.GL_MODELVIEW)
    GLUT.glutTimerFunc(10, timer, 1)
    GLUT.glutMainLoop()
コード例 #2
0
ファイル: renderer.py プロジェクト: david-svitov/fishscanner
    def __init__(self):
        """
        Initialize and create GLUT window
        """
        glut.glutInit(sys.argv)
        glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA
                                 | glut.GLUT_DEPTH)
        glut.glutCreateWindow("OpenGL")
        glut.glutFullScreen()

        gl.glEnable(gl.GL_TEXTURE_2D)
        gl.glDisable(gl.GL_LIGHTING)
        gl.glEnable(gl.GL_BLEND)
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        gl.glEnableClientState(gl.GL_VERTEX_ARRAY)

        # Modify matrices for screen size
        width = glut.glutGet(glut.GLUT_SCREEN_WIDTH)
        height = glut.glutGet(glut.GLUT_SCREEN_HEIGHT)
        gl.glViewport(0, 0, width, height)
        gl.glMatrixMode(gl.GL_PROJECTION)
        aspect = width / height
        gl.glOrtho(-aspect, aspect, 1, -1, -1, 1)

        gl.glMatrixMode(gl.GL_MODELVIEW)
        gl.glLoadIdentity()
コード例 #3
0
ファイル: glutwindow.py プロジェクト: padeler/PyGLer
    def setFullscreen(self, state):
        '''
        If **state** is True, the set_fullscreen() method requests the window
        manager to place the window in the fullscreen state. If **state** is
        False the set_fullscreen() method requests the window manager to toggle
        off the fullscreen state for the window. Note that in any case, you
        shouldn't not assume the window state is definitely set afterward,
        because other entities (e.g. the user or window manager) could
        fullscreen/unfullscreen it again, and not all window managers honor
        requests to fullscreen windows.

        :param bool state:
            Fullscreen state to be set.
        '''

        if self._fullscreen == state:
            return

        if state == True:
            glut.glutSetWindow( self._id )
            self._saved_width  = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
            self._saved_height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
            self._saved_x = glut.glutGet(glut.GLUT_WINDOW_X)
            self._saved_y = glut.glutGet(glut.GLUT_WINDOW_Y)
            self._fullscreen = True
            glut.glutFullScreen()
        else:
            self._fullscreen = False
            glut.glutSetWindow( self._id )
            glut.glutReshapeWindow(self._saved_width, self._saved_height)
            glut.glutPositionWindow( self._saved_x, self._saved_y )
            glut.glutSetWindowTitle( self._title )
コード例 #4
0
 def render(self):
     """
         Render the scene using the sphere display list
     """
     if self.do_exit:
         print('renderer exiting ...')
         # glut event loop needs hard exit ...
         sys.exit(0)
     if self.bodies is None:
         time.sleep(1 / self.fps)
         return
     GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
     GL.glMatrixMode(GL.GL_PROJECTION)
     GL.glLoadIdentity()
     x_size = GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH)
     y_size = GLUT.glutGet(GLUT.GLUT_WINDOW_HEIGHT)
     GLU.gluPerspective(60, float(x_size) / float(y_size), 0.05, 10)
     GL.glMatrixMode(GL.GL_MODELVIEW)
     GL.glLoadIdentity()
     GL.glTranslatef(-_CAMERA_POSITION[0], -_CAMERA_POSITION[1],
                     -_CAMERA_POSITION[2])
     self.mouse_interactor.apply_transformation()
     for body_index in range(self.bodies.shape[0]):
         body = self.bodies[body_index, :]
         GL.glPushMatrix()
         GL.glTranslatef(body[0], body[1], body[2])
         GL.glScalef(body[3], body[3], body[3])
         GL.glCallList(self.sphere)
         GL.glPopMatrix()
     GLUT.glutSwapBuffers()
コード例 #5
0
def main():
    light_position = (7, 2, 1)    
    GLUT.glutInit(argv)
    GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)
    larguraTela = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
    alturaTela = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)
    larguraJanela = round(2 * larguraTela / 3)
    alturaJanela = round(2 * alturaTela / 3)
    GLUT.glutInitWindowSize(larguraJanela, alturaJanela)
    GLUT.glutInitWindowPosition(round((larguraTela - larguraJanela) / 2), round((alturaTela - alturaJanela) / 2))
    GLUT.glutCreateWindow(janela)
    GLUT.glutReshapeFunc(reshape)
    GLUT.glutDisplayFunc(draw)
    GLUT.glutMouseFunc(clique)
    GL.glShadeModel(GL.GL_SMOOTH)
    GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, dados[0][0])
    GL.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, dados[0][1])
    GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, dados[0][2])
    GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, dados[0][3])
    GL.glEnable(GL.GL_LIGHTING)
    GL.glEnable(GL.GL_LIGHT0)
    GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position)
    GL.glEnable(GL.GL_MULTISAMPLE)
    GL.glEnable(GL.GL_DEPTH_TEST)
    GL.glClearColor(*corFundo)
    GLU.gluPerspective(45, larguraJanela / alturaJanela, 0.1, 50.0)
    GLUT.glutTimerFunc(50, timer, 1)
    GLUT.glutMainLoop()
コード例 #6
0
    def __glDraw(self):
        gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
        gl.glEnableClientState(gl.GL_COLOR_ARRAY)
        gl.glClear(gl.GL_COLOR_BUFFER_BIT)
        width = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
        height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
        if width == 0:
            return

        wh = width * 1.0 / height
        ctime = float(time.time()) - float(self.initTime)
        gl.glUniformMatrix2fv(self.timeloc, 1, False, [ctime, 0.0, 0.0, ctime])
        for varIndex, varValue in self.fractalSettings.vars.items():
            cValue = [varValue, 0.0, 0.0, varValue]
            gl.glUniformMatrix2fv(self.varloc[varIndex], 1, False, cValue)
        st = self.fractalSettings
        vertexAttrib = [st.center[0], st.center[1], st.scale, wh]
        gl.glVertexAttrib4f(1, *vertexAttrib)
        gl.glBegin(gl.GL_TRIANGLE_FAN)
        gl.glVertex2f(-1, -1)
        gl.glVertex2f(-1, 1)
        gl.glVertex2f(1, 1)
        gl.glVertex2f(1, -1)
        gl.glEnd()
        gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
        gl.glDisableClientState(gl.GL_COLOR_ARRAY)
        glut.glutSwapBuffers()
コード例 #7
0
ファイル: glut.py プロジェクト: joe311/vispy
 def _vispy_get_geometry(self):
     # Should return widget (x, y, w, h)
     glut.glutSetWindow(self._id)
     x = glut.glutGet(glut.GLUT_WINDOW_X)
     y = glut.glutGet(glut.GLUT_WINDOW_Y)
     w = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
     h = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
     return x, y, w, h
コード例 #8
0
ファイル: glutwindow.py プロジェクト: padeler/PyGLer
 def func(index):
     handler, fps = self._timer_stack[index]
     t = glut.glutGet(glut.GLUT_ELAPSED_TIME)
     dt = (t - self._timer_date[index])/1000.0
     self._timer_date[index] = t
     handler(dt)
     glut.glutTimerFunc(int(1000./fps), func, index)
     self._timer_date[index] = glut.glutGet(glut.GLUT_ELAPSED_TIME)
コード例 #9
0
 def func(index):
     handler, fps = self._timer_stack[index]
     t = glut.glutGet(glut.GLUT_ELAPSED_TIME)
     dt = (t - self._timer_date[index])/1000.0
     self._timer_date[index] = t
     handler(dt)
     glut.glutTimerFunc(int(1000./fps), func, index)
     self._timer_date[index] = glut.glutGet(glut.GLUT_ELAPSED_TIME)
コード例 #10
0
 def _vispy_get_geometry(self):
     # Should return widget (x, y, w, h)
     glut.glutSetWindow(self._id)
     x = glut.glutGet(glut.GLUT_WINDOW_X)
     y = glut.glutGet(glut.GLUT_WINDOW_Y)
     w = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
     h = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
     return x, y, w, h
コード例 #11
0
    def display(self, camera_tr_vec, camera_rot_mat, camera_fov_y,
                tracked_cam_track_pos_float):
        """
        Draw everything with specified render camera position, projection parameters and 
        tracked camera position

        :param camera_tr_vec: vec3 position of render camera in global space
        :param camera_rot_mat: mat3 rotation matrix of render camera in global space
        :param camera_fov_y: render camera field of view. To be used for building a projection
        matrix. Use glutGet to calculate current aspect ratio
        :param tracked_cam_track_pos_float: a frame in which tracked camera
        model and frustrum should be drawn (see tracked_cam_track_pos for basic task)
        :return: returns nothing
        """

        GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)

        aspect_ratio = GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH) / GLUT.glutGet(
            GLUT.GLUT_WINDOW_HEIGHT)

        proj_mat = _build_projection_matrix(camera_fov_y, aspect_ratio, 0.1,
                                            100)
        unrotate_mat = _build_rotation_matrix(np.linalg.inv(camera_rot_mat))
        untranslate_mat = _build_translation_matrix(-camera_tr_vec)
        mvp = proj_mat.dot(
            unrotate_mat.dot(untranslate_mat.dot(_opencvgl_matrix)))

        self._render_in_mode(mvp, self._points_vbo, self._colors_vbo,
                             self._count, GL.GL_POINTS)
        self._render_in_mode(mvp, self._cam_points_vbo, self._cam_colors_vbo,
                             self._cam_count, GL.GL_LINE_STRIP)

        # a frame in which a tracked camera model and frustrum should be drawn
        # without interpolation
        tracked_cam_track_pos = int(tracked_cam_track_pos_float)
        cam_track_pos = self._tracked_cam_track[tracked_cam_track_pos]
        frustrum_points = self._get_frustrum_points(
            cam_track_pos, self._tracked_cam_parameters.fov_y,
            self._tracked_cam_parameters.aspect_ratio, 20.0)
        frustrum_border_points = np.array([
            frustrum_points[0], frustrum_points[1], frustrum_points[1],
            frustrum_points[2], frustrum_points[2], frustrum_points[3],
            frustrum_points[3], frustrum_points[0], cam_track_pos.t_vec,
            frustrum_points[0], cam_track_pos.t_vec, frustrum_points[1],
            cam_track_pos.t_vec, frustrum_points[2], cam_track_pos.t_vec,
            frustrum_points[3]
        ],
                                          dtype=np.float32)

        points_vbo = vbo.VBO(frustrum_border_points.reshape(-1))
        yellow_color = [1, 1, 0]
        colors_vbo = vbo.VBO(
            np.array(yellow_color * len(frustrum_border_points),
                     dtype=np.float32))
        self._render_in_mode(mvp, points_vbo, colors_vbo,
                             len(frustrum_border_points), GL.GL_LINES)

        GLUT.glutSwapBuffers()
コード例 #12
0
 def get_dimensions(self):
     d = {}
     d['window_width'] = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
     d['window_height'] = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
     d['subwindow_width'] = self.width_pct * d['window_width']
     d['subwindow_height'] = self.height_pct * d['window_height']
     d['subwindow_origin_x'] = self.x1_pct * d['window_width']
     d['subwindow_origin_y'] = self.y1_pct * d['window_height']
     return d
コード例 #13
0
 def _render_screen_texture(self, inv_view_mat):
     GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self._camera_screen_frame_buffer)
     GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
     GL.glViewport(0, 0, _SCREEN_TEXTURE_W, _SCREEN_TEXTURE_H)
     mvp = self._tracked_cam_projection.dot(np.linalg.inv(inv_view_mat))
     self._render_point_cloud(mvp)
     GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
     GL.glViewport(0, 0, GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH),
                   GLUT.glutGet(GLUT.GLUT_WINDOW_HEIGHT))
コード例 #14
0
 def set_fullscreen(self, state):
     ''' Exit fullscreen mode '''
     self._fullscreen = state
     if state:
         self._saved_width  = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
         self._saved_height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
         glut.glutFullScreen()
     else:
         glut.glutReshapeWindow(self._saved_width, self._saved_height)
コード例 #15
0
    def get_size(self):
        '''Return the current size of the window.

        The window size does not include the border or title bar.

        :rtype: (int, int)
        :return: The width and height of the window, in pixels.
        '''
        width  = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
        height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
        return width,height
コード例 #16
0
 def snapshot(self, path):
     import cv2
     self.on_draw()
     x = 0
     y = 0
     width = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
     height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
     data = gl.glReadPixels(x, y, width, height, gl.GL_BGR, gl.GL_UNSIGNED_BYTE)
     data = np.fromstring(data, dtype=np.uint8)
     cv2.imwrite(
         path, np.flipud(data.reshape((height, width, 3)))
     )
コード例 #17
0
ファイル: glutwindow.py プロジェクト: padeler/PyGLer
    def getPosition(self):
        '''
        The get_position() method returns the current posiiton of the window. 

        :rtype: (int, int)
        :return: The current window coordinates, in pixels.
        '''

        glut.glutSetWindow( self._id )
        self._x = glut.glutGet( glut.GLUT_WINDOW_X )
        self._y = glut.glutGet( glut.GLUT_WINDOW_Y )
        return self._x, self._y
コード例 #18
0
def main():
    GLUT.glutInit(argv)
    GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA
                             | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)

    # Creating a screen with good resolution proportions
    screen_width = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
    screen_height = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)

    window_width = round(2 * screen_width / 3)
    window_height = round(2 * screen_height / 3)

    GLUT.glutInitWindowSize(window_width, window_height)
    GLUT.glutInitWindowPosition(round((screen_width - window_width) / 2),
                                round((screen_height - window_height) / 2))
    GLUT.glutCreateWindow(window_name)

    # Reshape Function
    GLUT.glutReshapeFunc(reshape)

    # Drawing Function
    GLUT.glutDisplayFunc(draw)

    # Input Functions
    GLUT.glutSpecialFunc(special_key_pressed)
    GLUT.glutKeyboardFunc(key_pressed)
    GLUT.glutMouseFunc(mouse_click)
    GLUT.glutMotionFunc(mouse_move)

    #GL.glShadeModel(GL.GL_FLAT)
    GL.glShadeModel(GL.GL_SMOOTH)

    #First Material
    GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, materials[0][0])
    GL.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, materials[0][1])
    GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, materials[0][2])
    GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, materials[0][3])

    light_position = (10, 0, 0)
    GL.glEnable(GL.GL_LIGHTING)
    GL.glEnable(GL.GL_LIGHT0)
    GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position)

    GL.glEnable(GL.GL_MULTISAMPLE)
    GL.glEnable(GL.GL_DEPTH_TEST)

    GL.glClearColor(*background_color)

    # Pre-render camera positioning
    GLU.gluPerspective(45, window_width / window_height, 0.1, 50.0)

    GLUT.glutTimerFunc(50, timer, 1)
    GLUT.glutMainLoop()
コード例 #19
0
    def display(self, camera_tr_vec, camera_rot_mat, camera_fov_y,
                tracked_cam_track_pos_float):
        """
        Draw everything with specified render camera position, projection parameters and 
        tracked camera position

        :param camera_tr_vec: vec3 position of render camera in global space
        :param camera_rot_mat: mat3 rotation matrix of render camera in global space
        :param camera_fov_y: render camera field of view. To be used for building a projection
        matrix. Use glutGet to calculate current aspect ratio
        :param tracked_cam_track_pos_float: a frame in which tracked camera
        model and frustrum should be drawn (see tracked_cam_track_pos for basic task)
        :return: returns nothing
        """
        tracked_cam_track_pos = int(tracked_cam_track_pos_float)
        tracked_cam_t = tracked_cam_track_pos_float - tracked_cam_track_pos
        self._camera_track.append(self._camera_track[-1])
        tracked_cam_pose = _interpolate_cam_pose(
            tracked_cam_t,
            *self._camera_track[tracked_cam_track_pos:tracked_cam_track_pos +
                                2])

        GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)

        aspect_ratio = GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH) / GLUT.glutGet(
            GLUT.GLUT_WINDOW_HEIGHT)

        mvp = _setup_projection(camera_fov_y, aspect_ratio, 0.1, 100) @ \
            np.linalg.inv(_setup_view(camera_tr_vec, camera_rot_mat))       # camera in OpenGL coordinates

        tracked_cam_p = _setup_projection(self._camera_params.fov_y,
                                          self._camera_params.aspect_ratio,
                                          0.1, 50)
        tracked_cam_mv = _opencv_opengl_transform @ \
            _setup_view(tracked_cam_pose.t_vec, tracked_cam_pose.r_mat) @ \
            _opencv_opengl_transform                           # camera in OpenCV coordinates -> conversion needed
        tracked_cam_mvp = tracked_cam_p @ np.linalg.inv(tracked_cam_mv)

        self._render_cam_frustum(
            mvp @ tracked_cam_mv @ np.linalg.inv(tracked_cam_p))
        self._render_points(
            mvp
            @ _opencv_opengl_transform)  # point cloud in OpenCV coordinates
        self._render_cam_track(
            mvp @ _opencv_opengl_transform)  # track in OpenCV coordinates
        self._render_cam(
            mvp @ tracked_cam_mv,  # camera model in OpenGL coordinates
            tracked_cam_mvp
            @ _opencv_opengl_transform  # point cloud in OpenCV coordinates
        )

        GLUT.glutSwapBuffers()
コード例 #20
0
    def __init__(self, width=None, height=None, caption=None, visible=True, fullscreen=False):

        event.EventDispatcher.__init__(self)

        self._event_queue = []
        if width and width > 0:
            self._width = width
        else:
            self._width = Window._default_width
        if height and height > 0:
            self._height = height
        else:
            self._height = Window._default_height
        if caption is None:
            caption = sys.argv[0]
        self._caption = caption

        self._saved_width  = self._width
        self._saved_height = self._height

        if _window is None:
            glut.glutInit(sys.argv)
            glut.glutInitDisplayMode(glut.GLUT_DOUBLE |
                                     glut.GLUT_RGBA   |
                                     glut.GLUT_DEPTH)
            self._window_id = glut.glutCreateWindow(self._caption)
        glut.glutDisplayFunc(self._display)
        glut.glutReshapeFunc(self._reshape)
        glut.glutKeyboardFunc(self._keyboard)
        glut.glutKeyboardUpFunc(self._keyboard_up)
        glut.glutMouseFunc(self._mouse)
        glut.glutMotionFunc(self._motion)
        glut.glutPassiveMotionFunc(self._passive_motion)
        glut.glutVisibilityFunc(self._visibility)
        glut.glutEntryFunc(self._entry)
        glut.glutSpecialFunc(self._special)
        glut.glutSpecialUpFunc(self._special_up)
        gl.glClearColor(0,0,0,0)
        self._visible = visible
        self._time = glut.glutGet(glut.GLUT_ELAPSED_TIME)
        if not visible:
            glut.glutHideWindow()
        else:
            glut.glutShowWindow()
        self.set_size(self._width, self._height)
        screen_width = glut.glutGet(glut.GLUT_SCREEN_WIDTH)
        screen_height= glut.glutGet(glut.GLUT_SCREEN_HEIGHT)
        glut.glutPositionWindow((screen_width-self._width)//2,
                                (screen_height-self._height)//2)
        self.fullscreen = fullscreen
コード例 #21
0
ファイル: appbase.py プロジェクト: showa-yojyo/notebook
    def timer(self, value):
        """The timer callback function."""

        if value != 0:
            caption = '{}: {} frames per secound @ {} x {}'.format(
                self.window_title.decode(),
                self.frame_count * 4,
                GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH),
                GLUT.glutGet(GLUT.GLUT_WINDOW_HEIGHT))

            GLUT.glutSetWindowTitle(caption)

        self.frame_count = 0
        GLUT.glutTimerFunc(250, self.timer, 1) # a quarter of a second
コード例 #22
0
ファイル: glutwindow.py プロジェクト: padeler/PyGLer
    def getSize(self):
        '''
        The get_size() methods returns the current size of the window and does
        not include the size of the window manager decorations (aka the window
        frame or border). 

        :rtype: (int, int)
        :return: The width and height of the window, in pixels.
        '''

        glut.glutSetWindow( self._id )
        self._width  = glut.glutGet( glut.GLUT_WINDOW_WIDTH )
        self._height = glut.glutGet( glut.GLUT_WINDOW_HEIGHT )
        return self._width, self._height
コード例 #23
0
ファイル: renderer.py プロジェクト: KatyaKos/computer_vision
    def _matrix_project(self, fovy, znear=0.5, zfar=100.):
        aspect_ratio = GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH) / GLUT.glutGet(
            GLUT.GLUT_WINDOW_HEIGHT)
        ymax = znear * np.tan(fovy / 2.)
        xmax = ymax * aspect_ratio
        delta = znear - zfar

        m = np.zeros((4, 4), dtype=np.float32)
        m[0, 0] = znear / xmax
        m[1, 1] = znear / ymax
        m[2, 2] = (zfar + znear) / delta
        m[2, 3] = 2. * znear * zfar / delta
        m[3, 2] = -1.

        return m
コード例 #24
0
    def display(self):

        self.fps_frame += 1
        self.fps_time = glut.glutGet(glut.GLUT_ELAPSED_TIME)

        if self.fps_time - self.fps_timebase > 1000:

            print('FPS:%4.2f' % (self.fps_frame * 1000.0 /
                                 (self.fps_time - self.fps_timebase)))
            self.fps_timebase = self.fps_time
            self.fps_frame = 0

        gl.glClear(self.clear_bit)
        x, y, w, h = self.viewport
        gl.glMatrixMode(gl.GL_PROJECTION)
        gl.glLoadIdentity()

        if self.isperspect:
            fovy, aspect, zNear, zFar = self.glu_perspect
            #print fovy
            glu.gluPerspective(fovy, w / float(h), zNear, zFar)
        else:
            left, right, bottom, top, near, far = self.gl_orthog
            gl.glOrtho(left, right, bottom, top, near, far)

        gl.glMatrixMode(gl.GL_MODELVIEW)
        gl.glLoadIdentity()
        eyex, eyey, eyez, centx, centy, centz, upx, upy, upz = self.glu_lookat
        glu.gluLookAt(eyex, eyey, eyez, centx, centy, centz, upx, upy, upz)
        self.mouse.applyTransformation()
        #Add objects
        self.plot.display()
        gl.glFlush()
        glut.glutSwapBuffers()
コード例 #25
0
ファイル: glviewer.py プロジェクト: schnorr/tupan
 def init_window(self):
     glut.glutInit(sys.argv)
     glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_ALPHA | glut.GLUT_DEPTH)
     glut.glutInitWindowPosition(
         (glut.glutGet(glut.GLUT_SCREEN_WIDTH) - self.window_width) // 2,
         (glut.glutGet(glut.GLUT_SCREEN_HEIGHT) - self.window_height) // 2,
     )
     glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_CONTINUE_EXECUTION)
     glut.glutInitWindowSize(self.window_width, self.window_height)
     self.window_handle = glut.glutCreateWindow(WINDOW_TITLE_PREFIX)
     glut.glutDisplayFunc(self.render_func)
     glut.glutReshapeFunc(self.resize_func)
     glut.glutMouseFunc(self.mouse)
     glut.glutMotionFunc(self.mouse_motion)
     glut.glutKeyboardFunc(self.keyboard)
     glut.glutSpecialFunc(self.keyboard_s)
コード例 #26
0
ファイル: canvas.py プロジェクト: krieghan/game_common
    def __init__(self,
                 world,
                 title='',
                 height=500,
                 width=500):
        self.world = world
        self.time_interval = 10
        GLUT.glutInit(sys.argv)
        self.lastTime = GLUT.glutGet(GLUT.GLUT_ELAPSED_TIME)
        GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | 
                                 GLUT.GLUT_RGB | 
                                 GLUT.GLUT_DEPTH)
        GLUT.glutInitWindowSize(height, width)
        GLUT.glutCreateWindow(title)
        GLUT.glutDisplayFunc(self.render)
        GLUT.glutReshapeFunc(self.onSize)

        self.init = False
        
        #initialized to actual values in setupView
        self.viewport_left = 0
        self.viewport_bottom = 0
        self.viewport_height = 0
        self.viewport_width = 0
        
        self.timeStep = 1
        self.timeElapsed = self.time_interval / 1000.0
コード例 #27
0
ファイル: gl-grid.py プロジェクト: changcunyuan/gl-agg
def on_display( ):
    gl.glClearColor(1,1,1,1)
    gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
    gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
    gl.glEnable(gl.GL_BLEND)

    global t, t0, frames
    t = glut.glutGet( glut.GLUT_ELAPSED_TIME )
    frames = frames + 1
    if t-t0 > 2500:
        print "FPS : %.2f (%d frames in %.2f second)" % (frames*1000.0/(t-t0), frames, (t-t0)/1000.0)
        t0, frames = t,0

    shader.bind()
    shader.uniformi( 'texture',           0)
    shader.uniformf( 'size',              w,h)
    shader.uniformf( 'major_grid_width',   major_grid_width )
    shader.uniformf( 'minor_grid_width',   minor_grid_width )
    shader.uniformf( 'major_grid_color',  *major_grid_color )
    shader.uniformf( 'minor_grid_color',  *minor_grid_color )
    shader.uniformf( 'major_tick_size',   *major_tick_size )
    shader.uniformf( 'minor_tick_size',   *minor_tick_size )
    shader.uniformf( 'major_tick_width',   major_tick_width )
    shader.uniformf( 'minor_tick_width',   minor_tick_width )
    shader.uniformf( 'major_tick_color',  *major_tick_color )
    shader.uniformf( 'minor_tick_color',  *minor_tick_color )
    axis.draw( gl.GL_TRIANGLES )
    shader.unbind()

    glut.glutSwapBuffers()
コード例 #28
0
ファイル: vertex_buffer.py プロジェクト: Flavsditz/projects
    def on_display():
        global cube, theta, phi, frame, time, timebase

        frame += 1
        time = glut.glutGet( glut.GLUT_ELAPSED_TIME )
        if (time - timebase > 1000):
            print frame*1000.0/(time-timebase)
            timebase = time;        
            frame = 0;

        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)

        gl.glPushMatrix()
        gl.glRotatef(theta, 0,0,1)
        gl.glRotatef(phi, 0,1,0)
        gl.glDisable( gl.GL_BLEND )
        gl.glEnable( gl.GL_LIGHTING )
        gl.glEnable( gl.GL_DEPTH_TEST )
        gl.glEnable( gl.GL_POLYGON_OFFSET_FILL )
        gl.glPolygonMode( gl.GL_FRONT_AND_BACK, gl.GL_FILL )
        cube.draw( gl.GL_QUADS, 'pnc' )
        gl.glDisable( gl.GL_POLYGON_OFFSET_FILL )
        gl.glEnable( gl.GL_BLEND )
        gl.glDisable( gl.GL_LIGHTING )
        gl.glPolygonMode( gl.GL_FRONT_AND_BACK, gl.GL_LINE )
        gl.glDepthMask( gl.GL_FALSE )
        gl.glColor( 0.0, 0.0, 0.0, 0.5 )
        cube.draw( gl.GL_QUADS, 'p' )
        gl.glDepthMask( gl.GL_TRUE )
        gl.glPopMatrix()

        glut.glutSwapBuffers()
コード例 #29
0
    def display(self):

        global last_time

        current_time = glut.glutGet(glut.GLUT_ELAPSED_TIME)

        Dt = current_time - last_time

        #print Dt
        
        now = self.time

        #if Dt < 40:

        for s in self.slots:

            if now >= self.slots[s]['slot'][0] and now <=self.slots[s]['slot'][1]:

                self.slots[s]['actor'].near_pick = self.near_pick

                self.slots[s]['actor'].far_pick = self.far_pick               
                
                self.slots[s]['actor'].display()

                

        last_time = current_time
コード例 #30
0
ファイル: render.py プロジェクト: Nickkreker/OpenCV-
    def animate(self):
        d_time_millis = GLUT.glutGet(
            GLUT.GLUT_ELAPSED_TIME) - self._data.prev_time
        self._data.prev_time += d_time_millis
        d_time = d_time_millis / 1000.0

        if self._data.key_states[ord(b'q')] or self._data.key_states[ord(
                b'e')]:
            if self._data.key_states[ord(b'q')]:
                self._tracked_cam_track_pos_float -= \
                    d_time * self._change_rates.track_pos
            if self._data.key_states[ord(b'e')]:
                self._tracked_cam_track_pos_float += \
                    d_time * self._change_rates.track_pos
            self._tracked_cam_track_pos_float = np.clip(
                self._tracked_cam_track_pos_float, 0,
                self._tracked_cam_track_len - 1)
            self._tracked_cam_track_pos_float = np.clip(
                self._tracked_cam_track_pos_float, 0,
                self._tracked_cam_track_len - 1)

        if self._data.key_states[ord(b'a')]:
            self.move_camera(d_time *
                             np.array([-self._change_rates.tr_xz, 0, 0]))
        if self._data.key_states[ord(b'd')]:
            self.move_camera(d_time *
                             np.array([+self._change_rates.tr_xz, 0, 0]))
        if self._data.key_states[ord(b's')]:
            self.move_camera(d_time *
                             np.array([0, 0, +self._change_rates.tr_xz]))
        if self._data.key_states[ord(b'w')]:
            self.move_camera(d_time *
                             np.array([0, 0, -self._change_rates.tr_xz]))

        GLUT.glutPostRedisplay()
def main():
    GLUT.glutInit(argv)
    GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA
                             | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)

    # Creating a screen with good resolution proportions
    screen_width = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
    screen_height = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)

    window_width = round(2 * screen_width / 3)
    window_height = round(2 * screen_height / 3)

    GLUT.glutInitWindowSize(window_width, window_height)
    GLUT.glutInitWindowPosition(round((screen_width - window_width) / 2),
                                round((screen_height - window_height) / 2))
    GLUT.glutCreateWindow(window_name)

    # Drawing Function
    GLUT.glutDisplayFunc(draw)

    # Input Functions
    GLUT.glutSpecialFunc(special_key_pressed)
    GLUT.glutKeyboardFunc(key_pressed)
    GLUT.glutMouseFunc(mouse_click)
    GLUT.glutMotionFunc(mouse_move)

    load_textures()

    GL.glEnable(GL.GL_MULTISAMPLE)
    GL.glEnable(GL.GL_DEPTH_TEST)
    GL.glEnable(GL.GL_TEXTURE_2D)

    GL.glClearColor(*background_color)
    GL.glClearDepth(1.0)
    GL.glDepthFunc(GL.GL_LESS)

    GL.glShadeModel(GL.GL_SMOOTH)
    GL.glMatrixMode(GL.GL_PROJECTION)

    # Pre-render camera positioning
    GLU.gluPerspective(-45, window_width / window_height, 0.1, 100.0)
    GL.glTranslatef(0.0, 0.0, -10)

    GL.glMatrixMode(GL.GL_MODELVIEW)

    GLUT.glutTimerFunc(10, timer, 1)
    GLUT.glutMainLoop()
コード例 #32
0
def on_idle():
    global t, t0, frames
    t = glut.glutGet( glut.GLUT_ELAPSED_TIME )
    frames = frames + 1
    if t-t0 > 2500:
        print "FPS : %.2f (%d frames in %.2f second)" % (frames*1000.0/(t-t0), frames, (t-t0)/1000.0)
        t0, frames = t,0
    glut.glutPostRedisplay()
コード例 #33
0
ファイル: network.py プロジェクト: gbrouwer/Tensor
def on_idle():

	#Advances frame
	global frame
	t = glut.glutGet(glut.GLUT_ELAPSED_TIME)
	frame = frame + 30
	if (frame > 1439):
		frame = frame - 1439 
コード例 #34
0
def Calculations():
    global objects
    global test
    global frames
    global start
    w = GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH)
    h = GLUT.glutGet(GLUT.GLUT_WINDOW_HEIGHT)
    cam.facing(fx, fy, w, h)
    GLUT.glutPostRedisplay()
    frames = frames + 1
    if frames > 100:
        elapsed = t.time() - start
        sys.stdout.write('\r')
        sys.stdout.write(str(frames / elapsed))
        sys.stdout.flush()
        frames = 0
        start = t.time()
コード例 #35
0
ファイル: meshviewer.py プロジェクト: classner/lace
 def snapshot(self, path):
     import cv
     self.on_draw()
     if False:  # pylint: disable=using-constant-test
         x, y, width, height = gl.glGetIntegerv(gl.GL_VIEWPORT)
     else:
         x = 0
         y = 0
         width = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
         height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
     data = gl.glReadPixels(x, y, width, height, gl.GL_BGR,
                            gl.GL_UNSIGNED_BYTE)
     image = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 3)
     flipped_image = cv.CreateImage((width, height), cv.IPL_DEPTH_8U, 3)
     cv.SetData(image, data)
     cv.Flip(image, flipped_image, 0)
     cv.SaveImage(path, flipped_image)
コード例 #36
0
 def init_window(self):
     glut.glutInit(sys.argv)
     glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA
                              | glut.GLUT_ALPHA | glut.GLUT_DEPTH)
     glut.glutInitWindowPosition(
         (glut.glutGet(glut.GLUT_SCREEN_WIDTH) - self.window_width) // 2,
         (glut.glutGet(glut.GLUT_SCREEN_HEIGHT) - self.window_height) // 2)
     glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE,
                        glut.GLUT_ACTION_CONTINUE_EXECUTION)
     glut.glutInitWindowSize(self.window_width, self.window_height)
     self.window_handle = glut.glutCreateWindow(WINDOW_TITLE_PREFIX)
     glut.glutDisplayFunc(self.render_func)
     glut.glutReshapeFunc(self.resize_func)
     glut.glutMouseFunc(self.mouse)
     glut.glutMotionFunc(self.mouse_motion)
     glut.glutKeyboardFunc(self.keyboard)
     glut.glutSpecialFunc(self.keyboard_s)
コード例 #37
0
def on_idle():

    #Advances frame
    global frame
    t = glut.glutGet(glut.GLUT_ELAPSED_TIME)
    frame = frame + 30
    if (frame > 1439):
        frame = frame - 1439
コード例 #38
0
ファイル: visualizer.py プロジェクト: mapleyustat/Tensor-4
def on_idle():

    #Advances frame
    global frame
    t = glut.glutGet(glut.GLUT_ELAPSED_TIME)
    frame = frame + 1
    if (frame > 50):
        frame = frame - 50
    print frame
コード例 #39
0
ファイル: visualizer.py プロジェクト: gbrouwer/Tensor
def on_idle():

	#Advances frame
	global frame
	t = glut.glutGet(glut.GLUT_ELAPSED_TIME)
	frame = frame + 1
	if (frame > 50):
		frame = frame - 50
	print frame
コード例 #40
0
def main():    
    GLUT.glutInit(argv)
    GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)
    larguraTela = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
    alturaTela = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)
    larguraJanela = round(2 * larguraTela / 3)
    alturaJanela = round(2 * alturaTela / 3)
    GLUT.glutInitWindowSize(larguraJanela, alturaJanela)
    GLUT.glutInitWindowPosition(round((larguraTela - larguraJanela) / 2), round((alturaTela - alturaJanela) / 2))
    GLUT.glutCreateWindow(janela)
    GLUT.glutDisplayFunc(draw)
    GLUT.glutMouseFunc(clique)
    GL.glEnable(GL.GL_MULTISAMPLE)
    GL.glEnable(GL.GL_DEPTH_TEST)
    GL.glClearColor(*corFundo)
    GLU.gluPerspective(-45, larguraJanela / alturaTela, 0.1, 100.0)
    GLUT.glutTimerFunc(10, timer, 1)
    GLUT.glutMainLoop()
コード例 #41
0
ファイル: esferatexturizada.py プロジェクト: MMAAia/CG
def main():    
    GLUT.glutInit(argv)
    GLUT.glutInitDisplayMode(
        GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE
    )

    screen_width = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
    screen_height = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)

    window_width = round(2 * screen_width / 3)
    window_height = round(2 * screen_height / 3)

    GLUT.glutInitWindowSize(window_width, window_height)
    GLUT.glutInitWindowPosition(
        round((screen_width - window_width) / 2), round((screen_height - window_height) / 2)
    )
    GLUT.glutCreateWindow("Textura Esfera  Globo")

    GLUT.glutDisplayFunc(draw)
    GLUT.glutKeyboardFunc(key_pressed)
    GLUT.glutMouseFunc(mouse_click)
    GLUT.glutMotionFunc(mouse_move)

    LoadTextures()

    GL.glEnable(GL.GL_MULTISAMPLE)
    GL.glEnable(GL.GL_DEPTH_TEST)
    GL.glEnable(GL.GL_TEXTURE_2D)

    GL.glClearColor(0.0, 0.0, 0.0, 1)
    GL.glClearDepth(1.0)
    GL.glDepthFunc(GL.GL_LESS)

    GL.glShadeModel(GL.GL_SMOOTH)
    GL.glMatrixMode(GL.GL_PROJECTION)

    # POSICAO DA CAMERA
    GLU.gluPerspective(-45, window_width / window_height, 0.1, 100.0)
    GL.glTranslatef(0.0, 0.0, -10)

    GL.glMatrixMode(GL.GL_MODELVIEW)

    GLUT.glutTimerFunc(10, timer, 1)
    GLUT.glutMainLoop()
コード例 #42
0
    def display(self, camera_tr_vec, camera_rot_mat, camera_fov_y,
                tracked_cam_track_pos_float):
        """
        Draw everything with specified render camera position, projection parameters and 
        tracked camera position
        :param camera_tr_vec: vec3 position of render camera in global space
        :param camera_rot_mat: mat3 rotation matrix of render camera in global space
        :param camera_fov_y: render camera field of view. To be used for building a projection
        matrix. Use glutGet to calculate current aspect ratio
        :param tracked_cam_track_pos_float: a frame in which tracked camera
        model and frustrum should be drawn (see tracked_cam_track_pos for basic task)
        :return: returns nothing
        """

        GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)

        view_mat = np.linalg.inv(
            _get_pose_matrix(data3d.Pose(camera_rot_mat, camera_tr_vec)))

        aspect_ratio = float(GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH)) / float(
            GLUT.glutGet(GLUT.GLUT_WINDOW_HEIGHT))
        focus_y = 1.0 / np.tan(camera_fov_y / 2.0)
        focus_x = focus_y / aspect_ratio

        near = 0.1
        far = 1000.0

        projection_mat = np.matrix([
            [focus_x, 0, 0, 0],
            [0, focus_y, 0, 0],
            [
                0, 0, -(far + near) / (far - near),
                -2 * far * near / (far - near)
            ],
            [0, 0, -1, 0],
        ])

        pv_matrix = projection_mat.dot(view_mat)

        self._point_cloud_renderer.render(pv_matrix)
        self._cam_track_line_renderer.render(pv_matrix)
        self._cam_renderer.render(pv_matrix, tracked_cam_track_pos_float)

        GLUT.glutSwapBuffers()
コード例 #43
0
def _make_vp(camera_tr_vec, camera_rot_mat, camera_fov_y):
    v = np.linalg.inv(
        np.block([[camera_rot_mat,
                   camera_tr_vec.reshape((3, 1))],
                  [np.zeros((1, 3)), np.ones((1, 1))]]))

    aspect_ratio = GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH) / GLUT.glutGet(
        GLUT.GLUT_WINDOW_HEIGHT)
    fy = calc_fy(camera_fov_y)
    fx = fy / aspect_ratio
    # camera_fov_x = camera_fov_y / aspect_ratio
    p = np.zeros((4, 4), dtype=np.float32)
    p[0, 0] = fx
    p[1, 1] = fy
    p[2, 2] = -(FAR + NEAR) / (FAR - NEAR)
    p[2, 3] = -2 * FAR * NEAR / (FAR - NEAR)
    p[3, 2] = -1

    return p @ v
コード例 #44
0
ファイル: canvas.py プロジェクト: krieghan/game_common
    def handleTime(self, value):
        try:
            currentTime = GLUT.glutGet(GLUT.GLUT_ELAPSED_TIME)
            self.world.update(currentTime=currentTime)
            
            self.render()

            GLUT.glutTimerFunc(self.time_interval, self.handleTime, None)
        except:
            traceback.print_exc()
            sys.exit()
コード例 #45
0
ファイル: scene.py プロジェクト: arokem/Fos
    def display(self):

        self.fps_frame+=1
        self.fps_time=glut.glutGet(glut.GLUT_ELAPSED_TIME)

        if self.fps_time - self.fps_timebase > 1000:

            print('FPS:%4.2f' % (self.fps_frame*1000.0/(self.fps_time-self.fps_timebase)))
            self.fps_timebase=self.fps_time
            self.fps_frame = 0
            
                
                                 

        gl.glClear(self.clear_bit)        
        x,y,w,h=self.viewport
        gl.glMatrixMode (gl.GL_PROJECTION)
        gl.glLoadIdentity()
        
        if self.isperspect:
            fovy,aspect,zNear,zFar=self.glu_perspect
            #print fovy
            glu.gluPerspective(fovy,w/float(h),zNear,zFar)
        else:
            left,right,bottom,top,near,far=self.gl_orthog
            gl.glOrtho(left, right, bottom, top, near, far)
        

        gl.glMatrixMode(gl.GL_MODELVIEW)       
        gl.glLoadIdentity()
        eyex,eyey,eyez,centx,centy,centz,upx,upy,upz=self.glu_lookat
        glu.gluLookAt(eyex,eyey,eyez,centx,centy,centz,upx,upy,upz)
        self.mouse.applyTransformation()
        #Add objects
        self.plot.display()
        gl.glFlush()
        glut.glutSwapBuffers()        
コード例 #46
0
ファイル: _glut.py プロジェクト: MatthieuDartiailh/vispy
 def _vispy_get_position(self):
     glut.glutSetWindow(self._id)
     x = glut.glutGet(glut.GLUT_WINDOW_X)
     y = glut.glutGet(glut.GLUT_WINDOW_Y)
     return x, y
コード例 #47
0
ファイル: _glut.py プロジェクト: MatthieuDartiailh/vispy
 def _vispy_get_size(self):
     glut.glutSetWindow(self._id)
     w = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
     h = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
     return w, h
コード例 #48
0
ファイル: backend_osxglut.py プロジェクト: rougier/unity
 def get_position(self):
     glut.glutSetWindow(self._native_window)
     self._x = glut.glutGet(glut.GLUT_WINDOW_W)
     self._y = glut.glutGet(glut.GLUT_WINDOW_Y)
     return self._x, self._y
コード例 #49
0
ファイル: backend_osxglut.py プロジェクト: rougier/unity
 def get_size(self):
     self.activate()
     self._width = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
     self._height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
     return self._width, self._height
コード例 #50
0
ファイル: backend_osxglut.py プロジェクト: rougier/unity
 def _reshape(self, width, height):
     self._width = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
     self._height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
     self.dispatch_event("on_resize", self._width, self._height)
コード例 #51
0
    def capture_mouse(self, x, y):
        """Capture mouse drag event."""

        self.width = GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH)
        self.height = GLUT.glutGet(GLUT.GLUT_WINDOW_HEIGHT)
        self.first_mouse_position = nds_coord(x, y, self.width, self.height)
コード例 #52
0
ファイル: demo-hearts.py プロジェクト: mdboom/gl-agg
    frames = frames + 1
    if t-t0 > 2500:
        print "FPS : %.2f (%d frames in %.2f second)" % (frames*1000.0/(t-t0), frames, (t-t0)/1000.0)
        t0, frames = t,0
    glut.glutPostRedisplay()


# -----------------------------------------------------------------------------
if __name__ == '__main__':
    import sys
    import OpenGL.GLUT as glut

    from glagg import curve4_bezier
    from glagg import PathCollection

    t0, frames = glut.glutGet(glut.GLUT_ELAPSED_TIME), 0
    glut.glutInit(sys.argv)
    glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)
    glut.glutCreateWindow("Shapes")
    glut.glutReshapeWindow(800, 800)
    glut.glutDisplayFunc(on_display)
    glut.glutReshapeFunc(on_reshape)
    glut.glutKeyboardFunc(on_keyboard)
    glut.glutIdleFunc(on_idle)

    collection = PathCollection()
    def heart():
        vertices = curve4_bezier( (0.0,-0.5), (0.75,+0.25), (.75,+1.0), (0.0,+0.5) )
        n = len(vertices)
        V = np.zeros((2*n,2))
        V[:n] = vertices
コード例 #53
0
ファイル: demo-asterisks.py プロジェクト: Eric89GXL/gl-agg
    t = glut.glutGet( glut.GLUT_ELAPSED_TIME )
    frames = frames + 1
    if t-t0 > 2500:
        print "FPS : %.2f (%d frames in %.2f second)" % (frames*1000.0/(t-t0), frames, (t-t0)/1000.0)
        t0, frames = t,0
    glut.glutPostRedisplay()

# -----------------------------------------------------------------------------
if __name__ == '__main__':
    import sys
    import OpenGL.GLUT as glut
    from shapes import star, asterisk
    from glagg import PathCollection

    t0, frames, t = 0,0,0
    t0 = glut.glutGet(glut.GLUT_ELAPSED_TIME)
    glut.glutInit(sys.argv)
    glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)
    glut.glutInitWindowSize(800, 800)
    glut.glutCreateWindow("Asterisks")
    glut.glutDisplayFunc(on_display)
    glut.glutReshapeFunc(on_reshape)
    glut.glutKeyboardFunc(on_keyboard)
    glut.glutIdleFunc(on_idle)

    collection = PathCollection()
    vertices = asterisk(n=5)

    for i in range(2000):
        collection.append(
            vertices, closed=True,
コード例 #54
0
ファイル: canvas.py プロジェクト: krieghan/game_common
 def getClientSizeTuple(self):
     return (GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH),
             GLUT.glutGet(GLUT.GLUT_WINDOW_HEIGHT))
コード例 #55
0
ファイル: glutwindow.py プロジェクト: padeler/PyGLer
    def __init__(self, size=None, position=None, title=None, fullscreen=False,enableAlpha=True,pointSize=2):
        '''
        Constructor
        '''
        self._mouse_x = 0
        self._mouse_y = 0
        self._button = mouse.NONE
        self._modifiers = None
        self._motionEventCounter=0
        self._time = None
        self._timer_stack = []
        self._timer_date = []
        self._title = title or "PyGLer" # FIXME: get default name from a central location 
        self._fullscreen = -1
        
        self.dragSensitivity = 5
        
        # Is there any glut loop already running ?
        if glut.glutGetWindow( ) == 0:
            glut.glutInit()
            glut.glutInitDisplayMode( glut.GLUT_DOUBLE |
                                      glut.GLUT_RGBA   |
                                      glut.GLUT_DEPTH )
            self._interactive = False
        else:
            self._interactive = True
            
        self._id = glut.glutCreateWindow( self._title )
        glut.glutShowWindow()        
        
        glut.glutDisplayFunc( self.redraw )
        glut.glutReshapeFunc( self._reshape )
        glut.glutKeyboardFunc( self._keyboard )
        glut.glutKeyboardUpFunc( self._keyboard_up )
        glut.glutMouseFunc( self._mouse )
        glut.glutMotionFunc( self._motion )
        glut.glutPassiveMotionFunc( self._passive_motion )
        glut.glutVisibilityFunc( self._visibility )
        glut.glutEntryFunc( self._entry )
        glut.glutSpecialFunc( self._special )
        glut.glutSpecialUpFunc( self._special_up )   
            
        GL.glEnable(GL.GL_DEPTH_TEST)
        
        GL.glEnable(GL.GL_BLEND)
        if enableAlpha:
            GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
        
        GL.glPolygonOffset(1, 1);
        GL.glEnable(GL.GL_POLYGON_OFFSET_FILL);

        GL.glPointSize(pointSize)
        GL.glEnable(GL.GL_PROGRAM_POINT_SIZE)
            
        if size is not None:
            width, height = size
            glut.glutReshapeWindow( width, height )

        width = glut.glutGet( glut.GLUT_WINDOW_WIDTH )
        height= glut.glutGet( glut.GLUT_WINDOW_HEIGHT )
        self._width = width
        self._height = height
        if position is not None:
            x,y = position
            glut.glutPositionWindow( x, y )
            
        x = glut.glutGet( glut.GLUT_WINDOW_X )
        y = glut.glutGet( glut.GLUT_WINDOW_X )
        self._x, self._y = x, y

        # These ones will be used when exiting fullscreen
        self._saved_width  = self._width
        self._saved_height = self._height
        self._saved_x = self._x
        self._saved_y = self._y

        self._time = glut.glutGet( glut.GLUT_ELAPSED_TIME )
        self._fullscreen = fullscreen
        if fullscreen:
            self.set_fullscreen(True)