Python 3D.

Practica 1 (Cuadrado y triangulo):
Captura:

Código:
import pygame
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

verticies = (
    (1, -1, -1),
    (1, 1, -1),
    (-1, 1, -1),
    (-1, -1, -1),
    (1, -1, 1),
    (1, 1, 1),
    (-1, -1, 1),
    (-1, 1, 1)
    )

edges = (
    (0,1),
    (0,3),
    (0,4),
    (2,1),
    (2,3),
    (2,7),
    (6,3),
    (6,4),
    (6,7),
    (5,1),
    (5,4),
    (5,7)
    )
#triangulo
#edges = (
#    (4,0),
#    (4,1),
#    (4,2),
#    (4,3),
#    (0,1),
#    (0,3),
#    (2,1),
#    (2,3),
#    )

def Cube():
    glBegin(GL_LINES)
    for edge in edges:
        for vertex in edge:
            glVertex3fv(verticies[vertex])
    glEnd()


def main():
    pygame.init()
    display = (800,600)
    pygame.display.set_mode(display, DOUBLEBUF|OPENGL)

    gluPerspective(45, (display[0]/display[1]), 0.1, 50.0)

    glTranslatef(0.0,0.0, -5)

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        glRotatef(1, 3, 1, 1)
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
        Cube()
        pygame.display.flip()
        pygame.time.wait(10)

#visual python
main()

---

Practica 2 (Cuadrado de colores):

Captura:

Código:

import sys, math, pygame

from operator import itemgetter

class Point3D:

    def __init__(self, x=0, y=0, z=0):

        self.x, self.y, self.z = float(x), float(y), float(z)

    def rotateX(self, angle):

        """ Rotates the point around the X axis by the given angle in degrees. """

        rad = angle * math.pi / 180

        cosa = math.cos(rad)

        sina = math.sin(rad)

        y = self.y * cosa - self.z * sina

        z = self.y * sina + self.z * cosa

        return Point3D(self.x, y, z)

    def rotateY(self, angle):

        """ Rotates the point around the Y axis by the given angle in degrees. """

        rad = angle * math.pi / 180

        cosa = math.cos(rad)

        sina = math.sin(rad)

        z = self.z * cosa - self.x * sina

        x = self.z * sina + self.x * cosa

        return Point3D(x, self.y, z)

    def rotateZ(self, angle):

        """ Rotates the point around the Z axis by the given angle in degrees. """

        rad = angle * math.pi / 180

        cosa = math.cos(rad)

        sina = math.sin(rad)

        x = self.x * cosa - self.y * sina

        y = self.x * sina + self.y * cosa

        return Point3D(x, y, self.z)

    def project(self, win_width, win_height, fov, viewer_distance):

        """ Transforms this 3D point to 2D using a perspective projection. """

        factor = fov / (viewer_distance + self.z)

        x = self.x * factor + win_width / 2

        y = -self.y * factor + win_height / 2

        return Point3D(x, y, self.z)

class Simulation:

    def __init__(self, win_width=640, win_height=480):

        pygame.init()

        self.screen = pygame.display.set_mode((win_width, win_height))

        pygame.display.set_caption("Figura de cubo 3D en python")

        self.clock = pygame.time.Clock()

        self.vertices = [

            Point3D(-1, 1, -1),

            Point3D(1, 1, -1),

            Point3D(1, -1, -1),

            Point3D(-1, -1, -1),

            Point3D(-1, 1, 1),

            Point3D(1, 1, 1),

            Point3D(1, -1, 1),

            Point3D(-1, -1, 1)

        ]

        # Define the vertices that compose each of the 6 faces. These numbers are

        # indices to the vertices list defined above.

        self.faces = [(0, 1, 2, 3), (1, 5, 6, 2), (5, 4, 7, 6), (4, 0, 3, 7), (0, 4, 5, 1), (3, 2, 6, 7)]

        # Define colors for each face

        self.colors = [(25, 0, 55), (0, 100, 50), (10, 5, 50), (20, 30, 5), (30, 25, 25), (2, 55, 10)]

        self.angle = 0

    def run(self):

        """ Main Loop """

        while 1:

            for event in pygame.event.get():

                if event.type == pygame.QUIT:

                    pygame.quit()

                    sys.exit()

            self.clock.tick(50)

            self.screen.fill((0, 32, 0))

            # It will hold transformed vertices.

            t = []

            for v in self.vertices:

                # Rotate the point around X axis, then around Y axis, and finally around Z axis.

                r = v.rotateX(self.angle).rotateY(self.angle).rotateZ(self.angle)

                # Transform the point from 3D to 2D

                p = r.project(self.screen.get_width(), self.screen.get_height(), 256, 4)

                # Put the point in the list of transformed vertices

                t.append(p)

            # Calculate the average Z values of each face.

            avg_z = []

            i = 0

            for f in self.faces:

                z = (t[f[0]].z + t[f[1]].z + t[f[2]].z + t[f[3]].z) / 4.0

                avg_z.append([i, z])

                i = i + 1

            # Draw the faces using the Painter's algorithm:

            # Distant faces are drawn before the closer ones.

            for tmp in sorted(avg_z, key=itemgetter(1), reverse=True):

                face_index = tmp[0]

                f = self.faces[face_index]

                pointlist = [(t[f[0]].x, t[f[0]].y), (t[f[1]].x, t[f[1]].y),

                             (t[f[1]].x, t[f[1]].y), (t[f[2]].x, t[f[2]].y),

                             (t[f[2]].x, t[f[2]].y), (t[f[3]].x, t[f[3]].y),

                             (t[f[3]].x, t[f[3]].y), (t[f[0]].x, t[f[0]].y)]

                pygame.draw.polygon(self.screen, self.colors[face_index], pointlist)

            self.angle += 1

            pygame.display.flip()

if __name__ == "__main__":

    Simulation().run()

---

Practica 3 (Grafica de barras):

Captura:

Código:

from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt

import numpy as np

fig = plt.figure()

ax1 = fig.add_subplot(111, projection='3d')

xpos = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]

ypos = [2,3,4,5,1,6,2,1,7,2,3,5,1,3,2]

num_elements = len(xpos)

zpos = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

dx = np.ones(15)

dy = np.ones(15)

dz = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]

ax1.bar3d(xpos, ypos, zpos, dx, dy, dz, color='#00ceaa')

plt.show()

---

Practica 4 (Juego):

Captura:

Click aquí.

---

Practica 5 (Esferas):

Capturas:

Código:

#!/usr/bin/python

# -*- coding: utf-8 -*-

# Librerías del programa

import sys

import math

from OpenGL.GL import *

from OpenGL.GLU import *

from OpenGL.GLUT import *

# Iluminación personalizada de la animación

class Luz(object):

    encendida = True

    colores = [(1., 1., 1., 1.), (1., 0.5, 0.5, 1.),

               (0.5,1.,0.5,1.), (0.5,0.5,1.,1.)]

    def __init__(self, luz_id, posicion):

        # Identificador del objeto de iluminación

        self.luz_id = luz_id

        # Posición de la iluminación

        self.posicion = posicion

        # Variable para seleccionar colores

        self.color_actual = 0

    # Tipo de iluminación

    def dibujar(self):

        light_id = self.luz_id

        color = Luz.colores[self.color_actual]

        glLightfv(light_id, GL_POSITION, self.posicion)

        glLightfv(light_id, GL_DIFFUSE, color)

        glLightfv(light_id, GL_CONSTANT_ATTENUATION, 0.1)

        glLightfv(light_id, GL_LINEAR_ATTENUATION, 0.05)

    def cambiar_color(self):

        self.color_actual += 1

        # Reinicia el color actual

        self.color_actual %= len(Luz.colores)

    def enable(self):

        if not Luz.encendida:

            glEnable(GL_LIGHTING)

            Luz.encendida = True

        glEnable(self.luz_id)

# Construcción de la Esfera

class Esfera(object):

    # Divisiones de norte a sur

    meridianos = 40

    # Divisiones este a oeste

    paralelos = 40

    # Constructor de la clase

    def __init__(self, radio, posicion, color):

        self.radio = radio

        self.posicion = posicion

        self.color = color

    # Función que dibuja una esfera

    def dibujar(self):

        # Ubicacion de la figura 3d

        glTranslatef(*self.posicion)

        # Especifica los parametros del material para la iluminación

        # GL_AMBIENT , GL_EMISSION

        glMaterialfv(GL_FRONT, GL_DIFFUSE, self.color)

        # Función especial para dibujar esferas

        glutSolidSphere(self.radio, Esfera.meridianos, Esfera.paralelos)

# Aplicación principal

class App(object):

    # Constructor de la clase

    def __init__(self, largo=800, ancho=600):

        # Titulo de la ventana

        self.titulo = 'Esferas con OpenGL'

        # Medidas de la ventana

        self.largo = largo

        self.ancho = ancho

        # Angulo de vision de la camara

        self.angulo = 0

        # Distancia de la camara

        self.distancia = 20

        # Instancia de la clase Luz

        self.iluminacion = Luz(GL_LIGHT0, (15, 5, 15, 1))

        # Instancia de la clase Esfera

        self.esfera1 = Esfera(2, (0, 0, 0), (1, 1, 1, 1))

        # Instancia de la clase Esfera

        self.esfera2 = Esfera(1, (4, 2, 0), (1, 0.4, 0.4, 1))

    # Función que crea la ventana y los graficos 3d

    def iniciar(self):

        # Inicializa la librería GLUT

        glutInit()

        # Funciones para inicializar la ventana

        glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH)

        glutInitWindowPosition(50, 50)

        glutInitWindowSize(self.largo, self.ancho)

        glutCreateWindow(self.titulo)

        # Activar las funciones graficas

        glEnable(GL_DEPTH_TEST)

        # Activar iluminación

        glEnable(GL_LIGHTING)

        # Seleccionar la constante de iluminación

        glEnable(GL_LIGHT0)

        # Activar la iluminación con las características de nuestra función

        self.iluminacion.enable()

        # Color de fondo

        glClearColor(.1, .1, .1, 1)

        glMatrixMode(GL_PROJECTION)

        aspect = self.largo / self.ancho

        gluPerspective(40., aspect, 1., 40.)

        glMatrixMode(GL_MODELVIEW)

        # Llamada para dibujar las figuras

        glutDisplayFunc(self.dibujar)

        # Llamada para activar las funciones del teclado

        glutSpecialFunc(self.keyboard)

        #Inicia el ciclo de la libreria

        glutMainLoop()

        # ...

    # Función que dibuja las figuras 3D

    def dibujar(self):

        # Coordenadas de la cámara

        x = math.sin(self.angulo) * self.distancia

        z = math.cos(self.angulo) * self.distancia

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        glLoadIdentity()

        # Coordenadas de la cámara

        # Posición

        # Dirección en la que mira

        # Orientación

        gluLookAt(x, 0, z,

                  0, 0, 0,

                  0, 1, 0)

        # Se crea la iluminación

        self.iluminacion.dibujar()

        # Se crea la primer esfera

        self.esfera1.dibujar()

        # Se crea la segunda esfera

        self.esfera2.dibujar()

        glutSwapBuffers()

    # Funciones del teclado

    def keyboard(self, tecla, x, y):

        if tecla == GLUT_KEY_INSERT:

            # Cerrar ventana

            sys.exit()

        if tecla == GLUT_KEY_UP:

            # Acercar la cámara

            self.distancia -= 0.1

        if tecla == GLUT_KEY_DOWN:

            # Alejar cámara

            self.distancia += 0.1

        if tecla == GLUT_KEY_LEFT:

            # Girar cámara a la izquierda

            self.angulo -= 0.05

        if tecla == GLUT_KEY_RIGHT:

            # Girar cámara a la derecha

            self.angulo += 0.05

        if tecla == GLUT_KEY_F1:

            # Cambiar color de las esferas

            self.iluminacion.cambiar_color()

        # Máxima y mínima distancia de la cámara

        self.distancia = max(10, min(self.distancia, 20))

        # Reiniciar el ángulo de giro

        self.angulo %= math.pi * 2

        # Actualiza el plano 3d y las figuras de acuerdo al movimiento de la camara

        glutPostRedisplay()

if __name__ == '__main__':

    app = App()

    app.iniciar()

---