Gráficos en la medicina

Desde hace varios siglos, el hombre se ha venido apoyando en la imagen para conseguir aumentar la fiabilidad y la facilidad de su trabajo en el campo médico. Para ello ha utilizado diversas técnicas, significando cada una de ellas una auténtica revolución respecto a su predecesora. Uno de los “precursores” en el estudio científico y detallado del terreno de la medicina a través de la imagen fue Andreas Vesalio (1514-1564), primero con su “Tabulae Anatomicae Sex” (1538) y luego con una de las obras más importantes del s.XVI, la “De Humani Corporis Fabri” (1543):

Pero Vesalio y sus sucesores dibujaban a mano todos sus “modelos”, algo que, desde una perspectiva moderna, es poco eficiente. No podrían haberse imaginado el desarrollo tan espectacular que iba a sufrir su campo tres siglos más tarde.

La segunda gran revolución fue el descubrimiento y desarrollo de una técnica basada en los rayos X. El éxito de esta técnica viene de que una imagen obtenida en una CT consigue distinguir diferencias mínimas de intensidad, hecho que permitió, por ejemplo, diferenciar, a nivel cerebral, las sustancias gris y blanca.

La tercera gran revolución lleva el nombre de Imagen por Resonancia Magnética (MR o MRI), que permite desde el estudio del cerebro de enfermos de esquizofrenia hasta el de los ligamentos de los deportistas. La MR es un fenómeno físico basado en las propiedades magnéticas que poseen los núcleos atómicos.

La cuarta gran revolución, la ecografía, está muy ligada a un instrumento bélico, el sonar, desarrollado por científicos franceses durante la Segunda Guerra Mundial. Se trata de una técnica no invasiva basada en la utilización de ultrasonidos (ondas sonoras de alta frecuencia) para estudiar la estructura de los tejidos, diferenciando tejidos sanos de tejidos patológicos. Un aparato llamado transductor emite estos ultrasonidos sobre una zona del cuerpo.

En los últimos años, el auge de la radiología intervencionista y la cirugía miniinvasiva ha supuesto la investigación y el desarrollo de nuevas técnicas y tecnologías capaces de minimizar el impacto de la acción médica en el paciente, las cuales conforman la quinta y última gran revolución en la imagen médica. Algunas de estas técnicas están basadas en, y/o utilizan, alguna de las anteriormente explicadas, pero otras suponen un avance extraordinario no sólo a nivel de la imagen en la medicina, sino en un contexto general a nivel imagen.

Educación y capacitación

A menudo, se utilizan como instrumentos de ayuda educativa modelos de sistemas físicos, financieros y económicos, los cuales se generan por computadora. Modelos de sistemas físicos, sistemas fisiológicos, tendencias de población o equipo, pueden ayudar a los estudiantes a comprender la operación del sistema. En el caso de algunas aplicaciones de capacitación, se diseñan sistemas especiales, como los simuladores para sesiones de práctica o capacitación de capitanes de barco, pilotos de avión, operadores de equipo pesado y el personal de control de tráfico aéreo. Algunos simuladores no tiene pantallas de video; por ejemplo, un simulador de vuelo que sólo tiene un panel de control como instrumento de vuelo. No obstante, la mayor parte de los simulado-res cuenta con pantallas gráficas para la operación visual.

Publicidad

La mejor publicidad gráfica siempre ha sido venerada y elevada a la categoría de arte. Propuestas creativas, fotografía, tecnología aplicada a la imagen, etc... todos son ingredientes de una fórmula donde existe un componente especial. El mensaje.

Sin duda el elemento quizás más importante de toda pieza artística y creativa, y como no, también de los anuncios de la publicidad gráfica donde el objetivo principal se fundamente en conseguir la forma más eficaz de transmitirlo sin necesidad apenas de recurrir a las palabras.

Graficos de entretenimiento

Es muy común utilizar métodos de gráficas por computadora para producir películas, videos musicales y programas de televisión. En ocasiones, se despliegan sólo imágenes gráficas y otras veces, se combinan los objetos con los actores y escenas en vivo. Por ejemplo, en una escena gráfica creada para la película Start Treck - The Wrath of Khan, se dibujan en forma de armazón el planeta y la nave espacial y se sonbrean con métodos de presentación para producir superficies sólidas. Al igual que pueden aparecer personas en forma de armazón combinadas con actores y una escena en vivo. Los videos musicales aprovechan las gráficas de muchas maneras, se pueden combinar objetos gráficos con acción en vivo, o se pueden utilizar técnicas de procesamiento de imágenes para producir una transformación de una persona o un objeto en otro (morphing).

Galleta de Jengibre.

Creacion  de Fuentes de Luz

Las fuentes de luz en OpenGL tienen una serie de propiedades tales como: el color, la posición y su dirección. La función utilizada para especificar dichas propiedades es glLight*.

La sintaxis de este comando es la siguiente:

void glLight{if}[v](GLenum light, GLenum pname, TYPE param);

De esta forma se crea la fuente de luz que indica el parámetro light, el cual puede recibir los valores GL_LIGHT0, GL_LIGHT1, … , GL_LIGHT7 (ocho fuentes de luz como máximo en la definición estándar de la librería). Las características de la luz se especifican en el parámetro pname utilizando las constantes que se muestran en la tabla adjunta. Finalmente, el argumento param indica los valores de la característica fijada en pname.

Nombre del parámetro	Valor por defecto	Significado
GL_AMBIENT	(0.0, 0.0, 0.0, 1.0)	intensidad ambiente RGBA de la luz
GL_DIFFUSE	(1.0, 1.0, 1.0, 1.0)	intensidad difusa RGBA de la luz
GL_SPECULAR	(1.0, 1.0, 1.0, 1.0)	intensidad especular RGBA de la luz
GL_POSITION	(0.0, 0.0, 1.0, 0.0)	posición (x,y,z,w) de la luz
GL_SPOT_DIRECTION	(0.0, 0.0, -1.0)	dirección (x,y,z) del foco de luz
GL_SPOT_EXPONENT	0.0	exponente del foco de luz
GL_SPOT_CUTOFF	180.0	ángulo del foco de luz
GL_CONSTANT_ATTENUATION	1.0	factor de atenuación constante
GL_LINEAR_ATTENUATION	0.0	factor de atenuación lineal
GL_QUADRATIC_ATTENUATION	0.0	factor de atenuación cuadrático

Nota: Los valores por defecto de GL_DIFFUSE y GL_SPECULAR se aplican sólo a GL_LIGTH0. Para  otras fuentes de luz, los valores  por defecto son (0.0, 0.0, 0.0, 1.0) para ambos casos.

Ejemplo de utilización del comando glLight*:

GLfloat light_ambient []  = { 0.0, 0.0, 0.0, 1.0 };

GLfloat light_diffuse []  = { 1.0, 1.0, 1.0, 1.0 };

GLfloat light_specular [] = { 1.0, 1.0, 1.0, 1.0 };

GLfloat light_position [] = { 1.0, 1.0, 1.0, 0.0 };

glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);

glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);

glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);

glLightfv(GL_LIGHT0, GL_POSITION, light_position);

Una vez creada la fuente de luz es necesario activar primero la iluminación de la escena (en caso contrario los objetos se visualizan únicamente con el color activo, sin incluir los efectos de luz, ni el tipo de material) y posteriormente cada una de las fuentes de luz que la iluminan. La función encargada de realizar dicha tarea es glEnable.

glEnable(GL_LIGHTING); {Activar el modelo de iluminación}

glEnable(GL_LIGHT0);   {Activar la fuente de luz 0}

Para desactivar la iluminación debe utilizarse la función glDisable con el argumento GL_LIGHTING. De igual forma apagaremos cada una de las fuentes de luz con la misma función utilizando como argumento la luz que se desea apagar.

Color

El color de la fuente de luz se indica mediante sus componentes ambiente, difusa y especular. El significado asociado con cada uno de ellos es el siguiente:

·      Ambiente. Indica la aportación a la iluminación ambiente de la escena

·      Difusa. Determina el color de la fuente de luz

·      Especular. Define el color del brillo especular que produce la fuente de luz

Posición

En OpenGL pueden utilizarse dos tipos de fuentes de luz, dependiendo de como se define su posición en el espacio:

·      Direccionales.      (x, y, z) indica el vector de dirección y w es cero. La luz se       localiza en el infinito

·      Posicionales.       (x, y, z, w) indican la posición en coordenadas homogéneas. La luz se encuentra en la escena

Por tanto, la componente homogénea w determina el tipo de luz (direccional si w=0, posicional si w=1), mientras que las coordenadas x, y, z determinan la posición o dirección a la fuente de luz. Hay que tener en cuenta que en OpenGL la posición o dirección de una fuente de luz recibe el mismo tratamiento que la posición de una primitiva geométrica, es decir, una fuente de luz esta sujeta a las mismas transformaciones que una primitiva de acuerdo con la matriz de modelo / vista (GL_MODELVIEW)

Atenuación

En el mundo real, la intensidad de iluminación de las luces decrece a medida que aumenta la distancia a las mismas. En OpenGL se puede obtener este efecto para las luces posicionales definiendo los parámetros de atenuación constante (K_c), lineal (K_l) y cuadrática (K_q). La ecuación utilizada es la siguiente:

factor de atenuación = 1 / (K_c + K_l*d + K_q*d²)

Calculo de la Normal en OpenGl

Una de las caracteristicas que se puede establecer de un vertice es el color, pero podemos establecer otras caracteristicas como coordenada de la textura o la normal que sirve para realizar los calculos de iluminacion resultante. No importa el orden en que se definan las caraceteristicas pero siempre se hara antes de definir el vertice.

glColor3f(1.0, 0.3, 0.4); //color del vertice
glNormal3f(1.0, 0.0, 0.0); //Normal del vertice
glTextCoord2f(0.0, 1.0); //Coordenada de la textura
glVertex3f (1.0, 3.2, 3.6); //vertice

El vector normal se utiliza para calcular la incidencia de la luz sobre el vertice, si el vector normal no es unitario el vertice estara sobreiluminado (mayor que 1) o infraluminado (menor que 1).

Es muy importante que para cada vertice se defina la normal, ya que OpenGL no asigna la normal a partir de la orientacion primitiva. De lo contrario utilizara como normal al ultima normal establecida.

Crucigrama Unidad 4

1. Superficies_DIFUSAS_ - se caracterizan por reflejar la luz en todas las direcciones. Paredes pintadas con mate.

2. La luz puede dejar una superficie mediante dos procesos fundamentales:

     •  Emisión _PROPIA_

    •  9. __REFLEXION__

3. Si la superficie es_OPACA_, reflexión y absorción significará de toda la luz que dé en la superficie

4. __SPOTLIGHTS____(Luces direccionales): se caracterizan por un rango delgado de ángulos por los cuales se emite luz

5. Se describe una fuente mediante una función de 5._INTENSIDAD_ o 8_LUMINANCIA_ de tres componentes.

6. Fuentes de _PUNTO_: emite luz de manera igual en todas las direcciones.

7. Luz_AMBIENTE_: lograr un nivel de luz uniforme en el cuarto. Esta   iluminación uniforme se llama

10. Superficies__ESPECULARES__ - se ven relumbrantes porque la mayoría de la luz reflejada ocurre en un rango de ángulos cercanos al ángulo de reflexión.

11. Luces DISTANTES: si la fuente de luz está lejos de la superficie, el vector no cambiará mucho según se mueve de un punto a otro, al igual que la luz del sol da en todos los objetos cercanos entre si con el mismo ángulo.

Técnicas de sombreado clásicas y avanzadas

Clásicas: iluminación local

Son luces que no son extensas, como las reales, sino inextensas, puntuales. Y se relacionan con los objetos como mónadas aisladas, sin tener en cuenta la interacción entre ellos.

• Cálculos de iluminación por vértices
• Para aplicar iluminación un objeto necesitamos asociar un vector normal a cada vértice del objeto.  Cuando tenemos la normal calculada tenemos que normalizarla, pero también podemos hacer que se encargue la OpengGl activando la normalización con el comando glEnable GL_NORMALIZE o desactivarla con glDisable GL_NORMALIZE.

• Posterior relleno de triángulos
• En esta etapa se trata de asignar colores a los pixels correspondientes al interior de cada triángulo proyectado que cae dentro del área de visualización. Los colores asignados deben calcularse por el método de Gouraud, interpolando linealmente entre los colores de los tres vértices.

• Renderizado en tiempo real
• La idea fundamental del procesado en tiempo real es que todos los objetos deben ser descompuestos en polígonos. Estos polígonos serán descompuestos a su vez en triángulos. Cada triángulo será proyectado sobre la ventana bidimensional y rellenado con los colores adecuados para reflejar los efectos de la iluminación, texturas, etc.

Realistas: iluminación global

Son sencillos y rápidos pero proporcionan imágenes muy simples, que no representan adecuadamente el modo en que la luz ilumina los objetos y los espacios. Los métodos principales que existen en la actualidad son ray tracing y radiosity.

• Trazado de rayos
• Se encarga de computar la interacción de la luz desde un punto de vista determinado y es particularmente adecuado para superficies reflectantes. Se traza un rayo desde la posición del observador a través de cada uno de los píxeles del plano de proyección.

• Radiosidad
• Es un conjunto de técnicas para el cálculo de la iluminación global que tratan de resolver el problema básico del transporte de la luz, donde sólo se puede modelar de forma óptima considerando que cada fuente luminosa emite un número enorme de fotones.

• Cálculos de iluminación por pixel
• Antes de que el color final del píxel sea decidido, un cálculo de iluminación debe ser computado para sombrear a los píxeles basados en alguna luz que puede estar presente en la escena.

• Alto acabado
• Un cálculo para todo el polígono. Obtenemos una intensidad  que aplicamos a un conjunto de puntos de un objeto. Aceleramos el proceso de síntesis.  El polígono representa una superficie plana real del objeto que se modela y no es una aproximación de un objeto curvo.

Sombreado Constante o Plano

Se obtiene una intensidad que se aplica a un conjunto de puntos de un objeto.

Interpolación de Intensidades (Gouraud)

Se basa en la interpolación de intensidad o color. Considera que facetas planas vecinas proceden de aproximar una superficie curva. Elimina en gran medida las discontinuidades de iluminación.

Interpolación de Normales (Phong)

Se basa en la interpolación de la dirección de la normal. Igual que en Gouraud, se interpola a lo largo de cada línea de barrido. Captura mejor los brillos especulares en el medio de facetas planas.

Ray-Tracing

Es una extensión al enfoque de rendering con un modelo de iluminación local. Está basado en la observación previa que, de los rayos de luz saliendo de una fuente, los únicos que contribuyen a la imagen son aquellos que entran al lente de la cámara sintética y pasan por el centro de proyección. 

Buffer de Profundidad

Se utiliza para eliminar las partes de los objetos que quedan ocultas tras los objetos, o partes del mismo objeto, más cercanos al observador.

Buffer de Stencil

Es una memoria intermedia que analiza y actualiza píxeles (con sus operaciones) junto con “depth buffer” o buffer de profundidad. Añade planos de bits adicionales para cada píxel además de los bits de color y profundidad. 

Luz Ambiente

Ilumina por igual todas las zonas en sombra para simular el efecto de interacción entre objetos que hace que las partes en sombra de los objetos queden parcialmente iluminadas.

Fuentes de Color

No solamente las fuentes de luz emiten diferentes cantidades de luz en diferentes frecuencias. Para las aplicaciones se puede modelar fuentes de luz en base a tres componentes primarios (RGB).

Spotlights (direccionales)

Los spotlights se caracterizan por un rango delgado de ángulos por los cuales se emite luz. Se puede construir un spotlight sencillo de una fuente de punto limitando los ángulos de donde la luz de la fuente se puede ver.

Fuentes de Luz Distantes

Según se mueve la fuente de luz a lo largo de la superficie, se debe recomputar el vector para calcular la intensidad en cada punto. Si la fuente de luz está lejos de la superficie, el vector no cambiará mucho según se mueve de un punto a otro. 

Intensidad Completa

La intensidad completa es exclusiva de los efectos de iluminación.

Programa Iluminacion



Codigo




#include <GL/glut.h>

float escala=0.2;
float angX=0.0f,angY=0.0f;
int ResX=800,ResY=600;
enum{EJE=2};
float angB=0.0f,angC=0.0f,angDE=0.0f;
float aceX=0.0f,aceY=-0.0001f;
float velX=0.001f,velY=0.0f;
float posX=0.0f,posY=10.0f;
//Definición del modelo de una luz
GLfloat light_Ambient [4] = { 0.2, 0.2, 0.2, 1.0};
GLfloat light_Diffuse [4] = { 1.0, 1.0, 1.0, 1.0};
GLfloat light_Position [4] = {20.0, 15.0, 10.0, 1.0};
//Definición de las caracteristicas opticas del material: coeficientes de reflexión
GLfloat material [4] = {1.0f, 0.2f, 0.2f, 1.0f };
GLfloat RedMaterial [4] = {1.0, 0.0, 0.0, 1.0 };
GLfloat GreenMaterial [4] = {0.0, 1.0, 0.0, 1.0 };
GLfloat BlueMaterial [4] = {0.0, 0.0, 1.0, 1.0 };
GLfloat WhiteMaterial [4] = {1.0, 1.0, 1.0, 1.0 };
GLfloat BlackMaterial [4] = {0.0, 0.0, 0.0, 1.0 };
GLfloat GrayMaterial [4] = {0.6, 0.6, 0.6, 1.0 };
void luces(void){
glEnable (GL_LIGHTING);
glEnable (GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_Ambient );
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_Diffuse );
glLightfv(GL_LIGHT0, GL_POSITION, light_Position );
}
void EjesReferencia()
{
glNewList(1,GL_COMPILE);
glBegin (GL_LINES);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, RedMaterial );
glVertex3f ( 0.0, 0.0, 0.0);
glVertex3f (20.0, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, GreenMaterial );
glVertex3f ( 0.0, 0.0, 0.0);
glVertex3f ( 0.0,20.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, WhiteMaterial );
glVertex3f ( 0.0, 0.0, 0.0);
glVertex3f ( 0.0, 0.0,20.0);
glEnd();
glEndList();
}
void pEJE(){
glNewList(EJE,GL_COMPILE);
glPushMatrix();
glutSolidSphere(1.0f,50,50);
glPopMatrix();
glEndList();
}
void RenderScene(void){
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glClearColor( 0.2f, 0.6f, 0.2f, 1.0f );
//AJUSTANDO LA CÁMARA
glLoadIdentity( );
glTranslatef(0.0f,0.0f,-5.0f);
glRotatef(angY,1.0f,0.0f,0.0f);
glRotatef(angX,0.0f,1.0f,0.0f);
//EJES DE REFERENCIA
glLineWidth(5);
glCallList(1);
glPushMatrix();
glScalef(escala,escala,escala);
//glTranslatef(1.0f,1.0f,1.0f);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, RedMaterial );
glPushMatrix();
glTranslatef(posX,posY,0.0f);
glCallList(EJE);
glPopMatrix();
//glFlush();
glutSwapBuffers();
}

void raton(int x, int y){
angX=(float)x;
angY=(float)y;
}
void idle(void){
velY+=aceY; posY+=velY;
velX+=aceX; posX+=velX;
if(posY<0.0f){posY=0.0f; velY*=-0.8f;
if(velY<0.01f){velX=0.0f; velY=0.0f;}
}
glutPostRedisplay();
}
int main(int a, char *b[]){
glutInit(&a,b);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(ResX,ResY);
glutInitWindowPosition(100,100);
glutCreateWindow("PELOTA QUE REBOTA");
glutDisplayFunc(RenderScene);
glutKeyboardFunc(teclado);
glutPassiveMotionFunc(raton);
glutIdleFunc(idle);
//OPENGL
glViewport( 0, 0, ResX, ResY );
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
glFrustum(-(float)ResX/ResY, (float)ResX/ResY, -1.0, 1.0, 2, 10000.0);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
luces();
EjesReferencia();
pEJE();
glutMainLoop();
return 0;
}

Piramide Unidad 3

 

 

#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;

GLint ancho=500;
GLint alto=500;

int hazPerspectiva = 0;

 void reshape(int width, int height){   
  glViewport(0, 0, width, height);   
  glMatrixMode(GL_PROJECTION);   
  glLoadIdentity();       
  if(hazPerspectiva)    
   gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);   
  else

      glOrtho(-4,4, -4, 4, -5, 10);   
  glMatrixMode(GL_MODELVIEW);    
  ancho = width;   
  alto = height;
 }


 void Piramide(void){    //------------------Funcion que dibuja la Piramide

//Cara Fontral-------------------------------------------------------------------------

  glShadeModel(GL_SMOOTH);
  glColor3f(1.0f, 0.0f, 0.0f);  
  glBegin(GL_POLYGON);       
  glVertex3f(-1.0f, 0.0f,  1.0f);   
  glVertex3f( 1.0f, 0.0f,  1.0f);   
  glVertex3f( 0.0f,  1.0f,  0.0f);
  glEnd();   



 
//cara trasera--------------------------------------------------------------------------

 glShadeModel(GL_SMOOTH);
 glColor3f(0.0f, 1.0f, 0.0f);
    glBegin(GL_POLYGON);      //cara trasera   
    glVertex3f(-1.0f, 0.0f,  -1.0f);   
    glVertex3f( 1.0f, 0.0f,  -1.0f);   
 glVertex3f( 0.0f,  1.0f,  0.0f);
    glEnd();   


//CARA LATERAL IZQUIERDA----------------------------------------------------------------

 glShadeModel(GL_SMOOTH);
 glColor3f(0.0f, 0.0f, 1.0f);   
    glBegin(GL_POLYGON);         
    glVertex3f(-1.0f, 0.0f,  1.0f);   
    glVertex3f( -1.0f, 0.0f, -1.0f);   
 glVertex3f( 0.0f,  1.0f,  0.0f);   
 glEnd();   

//CARA LATERAL DERECHA--------------------------------------------------------------------

 glShadeModel(GL_SMOOTH);
 glColor3f(1.0f, 1.0f, 0.0f);   
    glBegin(GL_POLYGON);      
 glVertex3f(1.0f, 0.0f,  1.0f);   
    glVertex3f( 1.0f, 0.0f,  -1.0f);   
 glVertex3f( 0.0f,  1.0f,  0.0f);
 glEnd();

 

//CARA ABAJO------------------------------------------------------------------------------------
  
 
 glShadeModel(GL_SMOOTH);
 glColor3f(1.0f, 0.0f, 1.0f);   
 glBegin(GL_QUADS);
 glVertex3f( 1.0f,0.0f, -1.0f);   
 glVertex3f( 1.0f, 0.0f,  1.0f);   
 glVertex3f(-1.0f,0.0f,  1.0f);  
 glVertex3f(-1.0f, 0.0f, -1.0f);   
 glEnd();

 }

 //-----------------------------------------------------------------------------------------------------------------

 void display(){
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    
  glLoadIdentity();    
 

  glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f); 
 
 
  Piramide();    
 
  glLoadIdentity();    
  glFlush();   
 
 
  glutSwapBuffers();  
 
  anguloCuboX+=0.1f;  
  anguloCuboY+=0.1f;  
 
 }

 void init(){
  glClearColor(0,0,0,0);   
  glEnable(GL_DEPTH_TEST);   
  ancho = 400;   
  alto = 400;
 }

void idle(){  display();  }

 int main(int argc, char **argv){   
 
  glutInit(&argc, argv);   
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);   
  glutInitWindowPosition(100, 100);   
  glutInitWindowSize(ancho, alto);  
  glutCreateWindow("Giro Piramide");   
  init();   
  glutDisplayFunc(display);   
  glutReshapeFunc(reshape);   
  glutIdleFunc(idle);   
  glutMainLoop();   
  return 0;

 }