LENGUAJES DE INTEFAZ

LENGUAJES DE INTEFAZ

1.1.-Importancia del lenguaje ensamblador

Importancia del lenguaje ensamblador

La importancia del lenguaje ensamblador radica principalmente que se trabaja directamente con el microprocesador; por lo cual se debe de conocer el funcionamiento interno de este, tiene la ventaja de que en el se puede realizar cualquier tipo de programas que en los lenguajes de alto nivel no lo pueden realizar. Otro punto sería que los programas en ensamblador ocupan menos espacio enmemoria.

Ventajas y desventajas del Lenguaje Ensamblador 

Ventajas1.     .- Como trabaja directamente con el microprocesador al ejecutar un programa, pues como este lenguaje es el más cercano a la máquina la computadora lo procesa mas rápido.
2.     Eficiencia de tamaño .- Un programa en ensamblador no ocupa mucho espacio en memoria porque no tiene que cargan librerías y demás como son los lenguajes de alto nivel
3.     Flexibilidad .- Es flexible porque todo lo que puede hacerse con una máquina, puede hacerse en el lenguaje ensamblador de esta máquina; los lenguajes de alto nivel tienen en una u otra forma limitantes para explotar al máximo los recursos de la máquina. O sea que en lenguaje ensamblador se pueden hacer tareas específicas que en un lenguaje de alto nivel no se pueden llevar acabo porque tienen ciertas limitantes que no se lo permite 

DesventajasTiempo de programación .- Como es un lenguaje de bajo nivel requiere más instrucciones para realizar el mismo proceso, en comparación con un lenguaje de alto nivel. Por otro lado, requiere de más cuidado por parte del programador, pues es propenso a que los errores de lógica se reflejen más fuertemente en la ejecución.Programas fuente grandes .- Por las mismas razones que aumenta el tiempo, crecen los programas fuentes; simplemente requerimos más instrucciones primitivas para describir procesos equivalentes. Esto es una desventaja porque dificulta el mantenimiento de los programas, y nuevamente reduce la productividad de los programadores.Peligro de afectar recursos inesperadamente .- Que todo error que podamos cometer, o todo riesgo que podamos tener, podemos afectar los recursos de la maquina, programar en este lenguaje lo más común que pueda pasar es que la máquina se bloquee o se reinicialice. Porque con este lenguaje es perfectamente posible (y sencillo) realizar secuencias de instrucciones inválidas, que normalmente no aparecen al usar un lenguaje de alto nivel.Falta de portabilidad.- Porque para cada máquina existe un lenguaje ensamblador; por ello, evidentemente no es una selección apropiada de lenguaje cuando deseamos codificar en una máquina y luego llevar los programas a otros sistemas operativos o modelos de computadoras.

1.2-El procesador y sus registros internos

La unidad central de procesamiento o unidad de procesamiento central (central processing unit), es el hardware dentro de un ordenador u otros dispositivos programables, que interpreta las instrucciones de un programa informático mediante la realización de las operaciones básicas aritméticas, lógicas y de entrada/salida del sistema.

Definición de registros: un registro es una memoria de alta velocidad y poca capacidad, integrada en el microprocesador, que permite guardar transitoriamente y acceder a valores muy usados, generalmente en operaciones matemáticas.

Los registros del procesador se emplean para controlar instrucciones en ejecución, manejar direccionamiento de memoria y proporcionar capacidad aritmética. Los registros son direccionables por medio de un nombre.

Tipos de registros

·                     Registros de segmento.

·                     Registros de propósito general.

·                     Registros de apuntadores.

·                     Registros de banderas.

·                     Registros de Pila.

·                     Registros Indice.

Registros de segmento

Un registro de segmento tiene 16 bits de longitud y facilita un área de memoria para direccionamiento conocida como el segmento actual.

·                     Registro CS:  El DOS almacena la dirección inicial del segmento de código de un programa en el registro CS. Esta dirección de segmento, mas un valor de desplazamiento en el registro apuntador de instrucción (IP), indica la dirección de una instrucción que es buscada para su ejecución.

·                     Registro DS:  La dirección inicial de un segmento de datos de programa es almacenada en el registro DS. En términos sencillos, esta dirección, mas un valor de desplazamiento en una instrucción, genera una referencia a la localidad de un byte especifico en el segmento de datos.

·                     Registro SS: El registro SS permite la colocación en memoria de una pila, para almacenamiento temporal de direcciones y datos. El DOS almacena la dirección de inicio del segmento de pila de un programa en le registro SS. Esta dirección de segmento, mas un valor de desplazamiento en el registro del apuntador de pila (SP), indica la palabra actual en la pila que esta siendo direccionada.

·                     Registros ES: Alguna operaciones con cadenas de caracteres (datos de caracteres) utilizan el registro extra de segmento para manejar el direccionamiento de memoria. En este contexto, el registro ES esta asociado con el registro DI (índice). Un programa que requiere el uso del registro ES puede inicializarlo con una dirección de segmento apropiada.

·                     Registros FS y GS:  Son registros extra de segmento en los procesadores 80386 y posteriores.

Registros de propósito general

Los registros de propósito general AX, BX, CX y DX son los caballos de batalla del sistema. Son únicos en el sentido de que se puede direccionarlos como una palabra o como una parte de un byte. El ultimo byte de la izquierda es la parte “alta”, y el ultimo byte de la derecha es la parte “baja”. Por ejemplo, el registro CX consta de una parte CH (alta) y una parte Cl (baja), y usted puede referirse a cualquier parte por su nombre.

·                     Registro AX:  El registro AX, el acumulador principal, es utilizado para operaciones que implican entrada/salida y la mayor parte de la aritmética. Por ejemplo, las instrucciones para multiplicar , dividir y traducir suponen el uso del AX. También, algunas operaciones generan código mas eficiente si se refieren al AX en lugar de a los otros registros.

·                     Registro BX: El BX es conocido como el registro base ya que es el único registro de propósito general que puede ser índice para direccionamiento indexado. También es común emplear el BX para cálculos.

·                     Registro DX: Es conocido como el registro de datos. Alguna operaciones de entrada/salida requieren uso, y las operaciones de multiplicación y división con cifras grandes suponen al DX y al AX trabajando juntos.

Registros Apuntadores

Los registros SP (apuntador de la pila) Y BP (apuntador de base) están asociados con el registro SS y permiten al sistema accesar datos en el segmento de la pila.

·                     Registro SP:  El apuntador de la pila de 16 bits esta asociado con el registro SS y proporciona un valor de desplazamiento que se refiere a la palabra actual que esta siendo procesada en la pila. Los procesadores 80386 y posteriores tienen un apuntador de pila de 32 bits, el registro ESP. El sistema maneja de forma automática estos registros.

·                     Registro BP: El BP de 16 bits facilita la referencia de parámetros, los cuales son datos y direcciones transmitidos vía pila. Los procesadores 80386 y posteriores tienen un BP ampliado de 32 bits llamado el registro EBP.

Registros Indice

Los registros SI y DI están disponibles para direccionamiento indexado y para sumas y restas.

·                     Registro SI: El registro índice fuente de 16 bits es requerido por algunas operaciones con cadenas (de caracteres). En este contexto, el SI esta asociado con el registro DS. Los procesadores 80386 y posteriores permiten el uso de un registro ampliado de 32 bits, el ESI.

·                     Registro DI: El registro índice destino también es requerido por algunas operaciones con cadenas de caracteres. En este contexto, el DI esta asociado con el registro ES. Los procesadores 80386 y posteriores permiten el uso de un registro ampliado de 32 bits, el EDI.

Registro de Banderas 

De los 16 bits del registro de banderas, nueve son comunes a toda la familia de procesadores 8086, y sirven para indicar el estado actual de la maquina y el resultado del procesamiento. Muchas instrucciones que piden comparaciones y aritmética cambian el estado de las banderas, algunas cuyas instrucciones pueden realizar pruebas para determinar la acción subsecuente. En resumen, los bits de las banderas comunes son como sigue:

·                     OF (Overflow, desbordamiento):  Indica desbordamiento de un bit de orden alto (mas a la izquierda) después de una operación aritmética.

·                     DF (dirección): Designa la dirección hacia la izquierda o hacia la derecha para mover o comparar cadenas de caracteres.

·                     IF (interrupción):  Indica que una interrupción externa, como la entrada desde el teclado, sea procesada o ignorada.

·                     TF (trampa): Permite la operación del procesador en modo de un paso. Los programas depuradores, como el DEBUG, activan esta bandera de manera que usted pueda avanzar en la ejecución de una sola instrucción a un tiempo, para examinar el efecto de esa instrucción sobre los registros de memoria.

·                     SF (signo): Contiene el signo resultante de una operación aritmética (0 = positivo y 1 = negativo).

·                     ZF (cero):  Indica el resultado de una operación aritmética o de comparación (0 = resultado diferente de cero y 1 = resultado igual a cero).

·                     AF (acarreo auxiliar): Contiene un acarreo externo del bit 3 en un dato de 8 bits para aritmética especializada.

·                     PF  (paridad): Indica paridad par o impar de una operación en datos de 8 bits de bajo orden (mas a la derecha).

·                     CF  (acarreo):  Contiene el acarreo de orden mas alto (mas a la izquierda) después de una operación aritmética; también lleva el contenido del ultimo bit en una operación de corrimiento o de rotación. Las banderas están en el registro de banderas en las siguientes posiciones:

Las banderas mas importantes para la programación en ensamblador son O, S, Z y C, para operaciones de comparación y aritméticas, y D para operaciones de cadenas de caracteres. Los procesadores 80286 y posteriores tienen algunas banderas usadas para propósitos internos, en especial las que afectan al modo protegido. Los procesadores 80286 y posteriores tienen un registro extendido de banderas conocido como Eflags.

Registros de PILA

La pila es un área de memoria importante y por ello tiene, en vez de uno, dos registros que se usan como desplazamiento (offset) para apuntar a su contenido. Se usan como complemento al registro y son:

·                     SP (Stack Pointer) : Se traduce como puntero de pila y es el que se reserva el procesador para uso propio en instrucciones de manipulado de pila. Por lo general , el programador no debe alterar su contenido.

·                     BP  (Base pointer):  Se usa como registro auxiliar. El programador puede usarlo para su provecho.

ADMINISTRACION DE BASE DE DATOS

ADMINISTRACION DE BASE DE DATOS

1.1.1 .-Funciones de un DBA

Modelado de Datos y Diseño de Base de Datos

Un DBA debe ser un profesional experto en la recopilación y análisis de las necesidades del usuario para obtener modelos de datos conceptuales y lógicos. Esta tarea es más difícil de lo que parece. Un modelo conceptual de datos describe los requisitos de datos a un nivel muy alto, un modelo de datos lógico proporciona en profundidad los detalles de los tipos de datos, longitudes, relaciones y cardinalidad. El DBA utiliza técnicas de normalización para ofrecer modelos de datos que reflejen las necesidades de los datos de la empresa.

Auditoria

Una de las tareas de un DBA es identificar qué usuarios tienen acceso a insertar, actualizar o eliminar datos, y cuándo. Una auditoría NO sólo podría ser necesaria por un tiempo limitado, para usuarios específicos o datos específicos. También puede ser requerida  24/7 para todos los datos que se introduzcan en el DBMS. Regularmente, para realizar las funciones de autorías los DBAs tienen que trabajar en combinación con los auditores internos y externos de la empresa.

Integración con aplicaciones

La mayoría de las empresas hoy en día utilizan aplicaciones de terceros (casi nadie ya desarrolla sus propias aplicaciones in-house), muy pocas de estas aplicaciones funcionan de manera aislada. En otras palabras, las aplicaciones tienen que interconectarse unas con otras, generalmente utilizando base de datos como el medio para compartir los datos. Los DBAs a menudo se involucran en los procesos de integrar las aplicaciones existentes con las bases datos que administran. Esto puede incluir la creación de aplicaciones a medida, scripts, etc.

Resguardo y recuperación de datos

Uno de los aspectos más fundamentales del trabajo del DBA es proteger los datos de la organización. Esto incluye hacer copias de seguridad periódicas de los datos y mantenerlos a salvo de la destrucción accidental o intencional. Además, diseñar, implementar y probar un plan de recuperación para que cuando se presenten los problemas, los datos se pueden restaurar rápidamente.

Inteligencia de negocios y almacenamiento de datos

Una de las áreas de mayor crecimiento para el DBA es la Inteligencia de Negocios (BI) y almacenamiento de datos. Esto se debe a que cada vez más organizaciones están tratando de extraer toda la información que pueda con el fin de tomar mejores decisiones de negocios.

Planificación de capacidad

En la mayoría de las organizaciones, el número y tamaño de las bases de datos crece rápidamente. Es la responsabilidad del DBA gestionar el creciente volumen de datos y diseñar los planes apropiados para administrarlos. Esto incluye también la gestión del hardware donde se almacenan los datos.

Administración de cambios

La configuración del servidor SQL Server o MySQL, el esquema de base de datos, el código de Transact-SQL, y muchas otras facetas del ecosistema de aplicaciones cambian con el tiempo. A menudo es la responsabilidad del DBA realizar el análisis de impacto antes de realizar los cambios dentro de una DBMS. Implementar cambios, hacer pruebas piloto y documentar todos los cambios y procedimientos es parte del trabajo de un DBA.

Desarrollo de aplicaciones

Muchos administradores de base datos deben de desarrollar aplicaciones y scripts con el objetivo de automatizar tareas relacionadas con la inserción, sustracción o borrado de información dentro del manejador de base de datos. En general, éste debe de colaborar a nivel de integración de sistema con los desarrolladores de aplicaciones, por lo que a veces se ve en la obligación de desarrollar código para casos específicos.

1.1.2 Relación del DBA con otras áreas de los Sistemas.

En sistemas muy complejos cliente/servidor y de tres capas, la base de datos es sólo uno de los elementos que determinan la experiencia de los usuarios en línea y los programas desatendidos. El rendimiento es una de las mayores motivaciones de los DBA para coordinarse con los especialistas de otras áreas del sistema fuera de las líneas burocráticas tradicionales. Uno de los deberes menos respetados por el administrador de base de datos es el desarrollo y soporte a pruebas, mientras que algunos otros encargados lo consideran como la responsabilidad más importante de un DBA. Las actividades de soporte incluyen la colecta de datos de producción para llevar a cabo pruebas con ellos; consultar a los programadores respecto al desempeño; y hacer cambios a los diseños de tablas de manera que se puedan proporcionar nuevos tipos de almacenamientos para las funciones de los programas.

mas figuras en 3D

codigo del juego


link de descarga del codigo del juego

codigo de las esferas

# Librerías del programaimport sys
import math
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *


# Iluminación personalizada de la animaciónclass 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 Esferaclass 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 principalclass 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(80., 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        # Reiniciar el ángulo de giro        self.angulo %= math.pi * 2        print(self.angulo)
        # Actualiza el plano 3d y las figuras de acuerdo al movimiento de la camara        glutPostRedisplay()
        self.distancia = max(10, min(self.distancia, 20))


if __name__ == '__main__':
    app = App()
    app.iniciar()

figuras en 3D

ejemplo 1:
codigo:

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)
    )


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)


main()

ejemplo 2:
codigo:

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),
    (0,0,1)

    )

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)


main()

ejemplo 3:
codigo:

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 = [(255, 0, 155), (255, 0, 0), (20, 255, 0), (0, 100, 15), (0, 255, 85), (85, 255, 0)]

        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()

ejemplo 4:

codigo:

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()