jueves, 8 de noviembre de 2012

Crucigrama


1. Superficies__________ - 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 _________
    •  9. ________________
3. Si la superficie es________, reflexión y absorción significará de toda la luz que dé en la superficie
4. ___________________(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 _____________ o 8____________ de tres componentes.
6. Fuentes de __________: emite luz de manera igual en todas las direcciones.
7. Luz_________: lograr un nivel de luz uniforme en el cuarto. Esta   iluminación uniforme se llama
10. Superficies_______________ - 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 _________: 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.

jueves, 1 de noviembre de 2012

Tecnicas de sombreado clasicas y avanzadas


Clásicas: Modelo de iluminación local
Son aquellos en los que se considera que la intensidad de luz en un punto de la superficie de un objeto se debe exclusivamente a las Fuentes luminosas.

Renderizado en Tiempo Real
La  renderización es el proceso de generar una imagen desde un modelo, y  se suele aplicar en la computación gráfica, más comúnmente a la infografía. En infografía este proceso se desarrolla con el fin de imitar un espacio 3D formado por estructuras poligonales, comportamiento de luces, texturas, materiales (agua,  madera,  metal, plástico,  tela, etcétera) y  animación, simulando ambientes y estructuras físicas verosímiles. Una de las partes más importantes de los programas dedicados a la  infografía son los motores de renderizado, los cuales son capaces de realizar técnicas complejas como  radiosidad,  raytrace, canal alfa, reflexión, refracción o iluminación global.
Cuando se trabaja en un  programa de diseño  3D asistido por ordenador, normalmente no es posible visualizar en tiempo real el acabado final deseado de una escena 3D compleja ya que esto requiere una potencia de cálculo demasiado elevada, por lo que se opta por crear el entorno 3D con una forma de visualización más simple y técnica, y luego generar el lento proceso de renderización para conseguir los resultados finales deseados. El tiempo de render depende en gran medida de los parámetros establecidos en los materiales y luces, así como de la configuración del programa de renderizado.
Realistas: Modelo de iluminación global
Son aquellos en los que se considera que la intensidad de luz en un punto de la superficie de un objeto se debe a las fuentes luminosas y al resto de los elementos existentes en la escena.
Trazado de rayos
Consiste en que –teniendo la posición y atributos físicos de cada uno de los objetos a iluminar, así como la situación, intensidad y tipo de fuentes de luz que iluminan los objetos, junto con la posición del observador y la del plano de proyección de la imagen (la pantalla), y el modo de iluminación o cálculo del color en un punto de la superficie de un objeto- 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 (una de las ventajas del raytracing es que los rayos que se procesan son sólo los rayos que parten del observador ), y por cada uno de estos rayos trazados se busca si interseca con alguno de los objetos que se representan; si no se encuentra ninguna intersección, para ese pixel, no se sigue el proceso y se le hace corresponder, por defecto, un color de fondo.  Si el rayo se encontrara con un objeto, se analizan los atributos físicos que tiene asignado el objeto y se resuelve según la modelización de la iluminación, calculando su color en el punto del objeto donde interseca el rayo.
Radiosidad
El método de radiosidad, consiste en que las reflexiones de la luz sobre los objetos se tratan como reflexiones difusas ideales de tal manera que la modelización de los efectos ópticos, como la de los espejos, por ejemplo, no se realiza. Este método hace aquello que no realiza el trazado de rayos. Para este método, los materiales de los objetos tienen superficies mate que no producen reflexiones espectaculares, por lo que la parte de energía que les llega, y que no haya sido absorbida por la superficie, se refleja por igual a lo largo de toda esta superficie del objeto.
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.
Sombreado Plano o Constante
Los tres vectores, l, n y v, pueden variar según se va entre puntos sobre una superficie.
• Para un polígono plano, n es constante.
• Si se asume un observador distante, v es constante sobre el polígono.
• Si la fuente de luz es distante, l es constante.
Si los tres vectores son constantes, entonces el cálculo de sombreado se lleva a cabo una sola vez para cada polígono, y se asignará la misma sombra a cada punto en el polígono.
Sombreado plano mostrará diferencias de sombreado entre los polígonos.
Sombreado Gouraud
En el sombreado Gouraud, se define la normal en un vértice como el promedio normalizado de las normales de los polígonos que comparten el vértice.
Desde la perspectiva de OpenGL, el sombreado Gouraud es sencillo. Se necesita solamente asignar correctamente las normales de vértices. Sin embargo, existe un problema, encontrar las normales para promediar. Si el programa es lineal, especificar una lista de vértices (y otras propiedades), no se tiene la información necesaria de cuales polígonos comparten un vértice. Lo que se requiere es una estructura de datos para representar un "mesh". Atravesar esta estructura de datos puede generar los vértices con las normales promediadas. Tal estructura de datos debe contener, de manera mínima, polígonos, vértices, normales, y propiedades de los materiales.
Sombreado Phong
Phong propuso que, en lugar de interpolar intensidades de los vértices, se interpole normales a lo largo del polígono. Para un polígono que comparte lados y vértices con otros polígonos.
Se puede computar normales en los vértices interpolando sobre las normales de los polígonos que comparten el vértice. Luego, se puede usar interpolación bilineal, para interpolar las normales sobre el polígono.
Una vez obtenidas las normales en cada punto, se puede hacer cálculos de sombreado independientes. Normalmente, este proceso se combinará con la rasterización del polígono.
Sombreado Phong producirá imágenes mas suaves que con el sombreado Gouraud, pero a un costo computacional mayor.
Recortado de caras traseras
 En una escena, los objetos se tapan a sí mismos y entre sí, quedando siempre partes ocultas al observador.
Las partes ocultas deben ser eliminadas de posteriores operaciones: proceso de visibilidad.
El proceso de visibilidad es complejo, por lo que existen numerosas soluciones.
 Técnicas implicadas:
Cálculo de normales
Ordenación
Algoritmos de visibilidad
Aceleración por coherencia

Técnicas de aceleración
o    Eliminación de caras traseras
o    Coherencia
o    Contenedores
Algoritmo fundamental en el espacio de la imagen: trazado de visuales (ray casting)
Algoritmos más conocidos:
Z- Buffer
Prioridad en lista
Scan- Line
Buffer de Profundidad
El z-buffering, o el buffer de profundidad es la parte de la memoria de nuestra tarjeta gráfica encargada de la visibilidad de nuestros gráficos 3D según las coordenadas de sus pixeles, con lo que se puede gestionar qué elementos de una escena renderizada son visibles y cuales permanecerán ocultos según sus posiciones en el eje Z (distancia a cámara).
En definitiva lo que se hace es comparar las profundidades de ambos gráficos para representar el objeto más cercano al observador. La profundidad elegida se guardará en el z-buffering reemplazando a la anterior.
Transparencias
La implementación de la transparencia en un programa OpenGL no suele ser sencilla. Podemos combinar los colores de los objetos para una escena simple que contenga unas pocas superficies opacas y transparentes utilizando el valor de mezcla alpha para especificar el grado de transparencia y procesando las superficies según su orden de profundidad. Pero las operaciones de mezcla de color OpenGL ignoran los efectos de refracción, y el manejo de superficies transparentes en escenas complejas con una diversidad de condiciones de iluminación o con animaciones puede resultar muy complicado. Así mismo, OpenGL no proporciona ninguna funcionalidad para simular la apariencia superficial de un objeto translúcido (como por ejemplo un cristal esmerilado), que dispersa de manera difusa la luz transmitida a través del material semitransparente. Por tanto, para mostrar superficies translúcidas o los efectos de iluminación resultantes de la refracción, necesitamos describir nuestras propias rutinas. Para simular los efectos de iluminación a través de un objeto translúcido, podemos utilizar una combinación de valores de textura superficial y de propiedades del material. Para los efectos de refracción, podemos desplazar las posiciones de píxel para las superficies que se encuentren detrás de un objeto transparente.
El blending es simplemente una técnica que se puede utilizar para obtener efectos de transparencias.
La transparencia mediante el blending es tan difícil como incómoda, pero si se controlan algunos aspectos de la escena, se puede conseguir el efecto deseado sin demasiada complejidad.

Buffer de Stencil
Stencill Buffer es una memoria intermedia que analiza y actualiza píxeles (con sus operaciones) junto con buffer de profundidad.  Añade planos de bits adicionales para cada píxel además de los bits de color y profundidad.
Stencil Buffer se puede pensar que simplemente etiqueta los píxeles en la interpretación o renderización de la escena en la pantalla para controlar las siguientes interpretaciones. Los pasos son siguientes:
1.    Dada una escena con una sombra fija. Los píxeles de la escena se podrían considerar con “dentro” de la sombra o “fuera”. Asumimos que podemos etiquetar cada píxel apropiadamente.
2.    Cuando los píxeles ya son etiquetados, actualizamos los píxeles etiquetados como “dentro” de la sombra. Y renderizamos la escena con la fuente de luz desactivada.
3.    Después actualizamos los píxeles etiquetados como “fuera” de la sombra. Activamos la luz y renderizamos otra vez.


Buffer de acumulación
El buffer de acumulación sirve para capturar el buffer de color en un fotograma y aplicarle acumulaciones del color de otro fotograma/s. Esto básicamente sirve para simular el efecto de estela que deja un objeto cuando se mueve muy rápidamente en el encuadre de la cámara.
Fuentes de Luz
La luz puede dejar una superficie mediante dos procesos fundamentales:
• Emisión propia
• Reflexión
Normalmente se piensa en una fuente de luz como un objeto que emite luz solo mediante fuentes de energía internas, sin embargo, una fuente de luz, como un foco, puede reflejar alguna luz incidente a esta del ambiente.
Se considerarán cuatro tipos básicos de fuentes, que serán suficientes para generar las escenas más sencillas:
1. Luz ambiente
2. Fuentes de punto
3. Spotlights (Luces direccionales)
4. Luces distantes
Fuentes de color
Para la mayoría de las aplicaciones, se puede modelar fuentes de luz en base a tres componentes primarios, RGB, y puede usar cada uno de los tres colores fuentes para obtener el componente de color correspondiente que un observador humano vería.
Se describe una fuente mediante una función de intensidad o luminancia de tres componentes: Cada uno de los componentes es la intensidad de los componentes rojo, verde y azul independientes.


Luz Ambiente
Como el modelo de iluminación es local, las partes que no están iluminadas por una fuente de luz se verían totalmente negras. Para evitar esto, se supone que hay una iluminación uniforme que es el promedio de la luz reflejada por los objetos, a la que llamamos ambiental.
En algunos cuartos, las luces se diseñan y ubican para proveer iluminación uniforme en el cuarto. Tal iluminación se logra mediante fuentes grandes con difusores cuyo propósito es esparcir la luz en todas las direcciones. Se puede crear una simulación precisa de tal iluminación, modelando todas las fuentes distribuidas, y luego integrando la iluminación de estas fuentes en cada punto de una superficie reflectora. Hacer tal modelo y generar la escena sería una tarea formidable para un sistema gráfico, especialmente si se desea ejecución en tiempo real. De manera alternativa, se puede ver el efecto deseado de las fuentes: lograr un nivel de luz uniforme en el cuarto. Esta iluminación uniforme se llama luz ambiente.

Spotlights (Luces 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. Se puede usar un cono cuyo ápice está en ps, apuntando en la dirección ls, y cuyo ancho está determinado por el ángulo θ.
Spotlights más realistas se caracterizan por una distribución de luz dentro del cono, normalmente con la mayoría de la luz concentrada en el centro del cono.
Fuentes de Luz Distantes
La mayoría de los cálculos de sombreado requieren la dirección de un punto sobre la superficie a la fuente de luz. Según se mueve a lo largo de la superficie, se debe recomputar este vector para calcular la intensidad en cada punto. Sin embargo, 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.

En la práctica, los cálculos para fuentes de luz distantes son similares a los cálculos para proyecciones paralelas; se reemplaza la ubicación de la fuente de luz por una dirección de la fuente de luz. Por lo tanto, en coordenadas homogéneas, una fuente de luz de punto en p0 se representará internamente como una matriz columna de cuatro dimensiones

donde la fuente de luz distante se representa mediante

que es la representación de un vector.

Intensidad Completa
La intensidad completa exclusivamente para efectos de iluminación es la siguiente:

piramide




#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, -1, 4, -5, 10);  
   glMatrixMode(GL_MODELVIEW);    
   ancho = width;  
   alto = height;
  }

 void Piramide(void){

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

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

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

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

  glShadeModel(GL_SMOOTH);  
  glBegin(GL_QUADS);
  glVertex3f( 1.0f,0.0f, -1.0f);  
  glVertex3f( 1.0f, 0.0f,  1.0f);
  glColor3f(1.0f, 1.0f, 0.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();    
  glScalef(2.5f, 2.5f, 2.5f);
   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("Tania Esparza");  
   init();  
   glutDisplayFunc(display);  
   glutReshapeFunc(reshape);  
   glutIdleFunc(idle);  
   glutMainLoop();  
   return 0;
 }

dibujos 3d y transformaciones geometricas

Tania Angélica Esparza Maldonado


miércoles, 17 de octubre de 2012

Problema II de examen

1. Resultados de los vertices despues de cada transformacion, usando excel


2. Programas en opengl de las transformaciones mencionadas:
a) tomando como base los vertices iniciales para cada transformación


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glTranslatef (-2,-2,0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Traslacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glScalef (0.5,0.5,0.0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Escalacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glRotatef(45.0,0,0,1);
glColor3f (1,1,.8);
glBegin(GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Rotacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

b) tomando las transformaciones en secuencia, es decir despues de la traslacion a los vertices resultantes aplicar la escalacion y al resultado aplicar la rotación.


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glTranslatef (-2,-2,0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Translacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (0,0);
glVertex2f (5,0);
glVertex2f (5,5);
glVertex2f (0,5);
glEnd();

glScalef (0.5,0.5,0.0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (0,0);
glVertex2f (5,0);
glVertex2f (5,5);
glVertex2f (0,5);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Escalacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (0,0);
glVertex2f (2.5,0);
glVertex2f (2.5,2.5);
glVertex2f (0,2.5);
glEnd();

glRotatef(45.0,0,0,1);
glColor3f (1,1,.8);
glBegin(GL_POLYGON);
glVertex2f (0,0);
glVertex2f (2.5,0);
glVertex2f (2.5,2.5);
glVertex2f (0,2.5);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Rotacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

lunes, 8 de octubre de 2012

Pelota que rebota


#include <GL/glut.h>
float escala=0.5; //tamaño de la Esfera.
int ResX=300,ResY=200;
float angX=0.0f,angY=0.0f;
enum{EJE=2};
float angB=0.0f,angC=0.0f,angDE=0.0f;
float aceX=0.0f,aceY=-0.00001f; //Entre mas pequeño sea el valor de la aceleracion de Y la pelota tarda mas
//tiempo en rebotar.
float velX=0.001f,velY=0.0f;
float posX=0.0f,posY=10.0f;
//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, 1.0, 0.0, 1.0 };
GLfloat GreenMaterial [4] = {0, 0.0, 1.0, 1.0 };
GLfloat BlueMaterial [4] = {1.0, 1.0, 1.0, 0.6 };
GLfloat WhiteMaterial [4] = {0.6, 0.0, 0.0, 1.0 };
GLfloat BlackMaterial [4] = {0.6, 1.0, 0.4, 1.0 };
GLfloat GrayMaterial [4] = {0.7, 0.6, 0.6, 1.0 };
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.0f, 0.0f, 0.0f, 0.0f );
//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);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, GreenMaterial );
glPushMatrix();
glTranslatef(posX,posY,0.0f);
glCallList(EJE);
glPopMatrix();
//glFlush();
glutSwapBuffers();
}
//esta funcion se usa para el rebote de la esfera.
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(200,300);
glutCreateWindow("REBOTA");
glutDisplayFunc(RenderScene);
glutIdleFunc(idle);
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);
pEJE();
glutMainLoop();
return 0;
}


sábado, 6 de octubre de 2012

Glosario


CAVE (Cave Automatic Virtual Environment). Es un entorno de realidad virtual inmersiva. Se trata de una sala en forma de cubo en la que hay proyectores orientados hacia las diferentes paredes, suelo y techo. Dependiendo del resultado que se quiera obtener se proyectará la imagen a todas o sólo alguna de las paredes de la sala.

Coordenadas Homogéneas. Las coordenadas homogéneas son un instrumento usado para describir un punto en el espacio proyectivo. Su notación en forma matricial se emplea en bibliotecas de programación gráfica en 3D como OpenGL y Direct3D.

Diafana. Que deja pasar a través la luz casi en su totalidad.

Ecografía. Es un procedimiento de imagenología que emplea los ecos de una emisión de ultrasonidos dirigida sobre un cuerpo u objeto como fuente de datos para formar una imagen de los órganos o masas internas con fines de diagnóstico. 

Espejo cóncavo. Es el que con su superficie forma un paraboloide de revolución, todos los rayos que inciden paralelos al eje del espejo, se reflejan pasando por el foco, y los que inciden pasando por el foco, se reflejan paralelos al eje.

Estereoscopía. Es cualquier técnica capaz de recoger información visual tridimensional y/o crear la ilusión de profundidad mediante una imagen estereográfica, un estereograma, o una imagen tridimensional.

Holografía. Es una técnica avanzada de fotografía, que consiste en crear imágenes tridimensionales. Para esto se utiliza un rayo láser, que graba microscópicamente una película fotosensible. Ésta, al recibir la luz desde la perspectiva adecuada, proyecta una imagen en tres dimensiones.

Obturador. Es el dispositivo que controla el tiempo durante el que llega la luz al dispositivo fotosensible. Este tiempo es conocido como la velocidad de obturación, y de él se desprenden conceptos como el congelado o el barrido fotográfico.

Pila (programacion). Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.

Proyector LCD. El sistema de pantalla de cristal líquido es el más simple, por tanto uno de los más comunes y accesibles para el uso doméstico.
Realidad virtual inmersiva. Los métodos inmersivos de realidad virtual con frecuencia se ligan a un ambiente tridimensional creado por un ordenador, el cual se manipula a través de cascos, guantes u otros dispositivos que capturan la posición y rotación de diferentes partes del cuerpo humano.

Reconstrucción 3D. Es el proceso mediante el cual, objetos reales, son reproducidos en la memoria de una computadora, manteniendo sus características físicas.

Viewport


Aplicaciones
·         Tener varias áreas de dibujo y proyección en una ventana
·         Mantener la proporción del aspecto

SINTAXIS
glViewport(Xminimo, Yminimo,Anco,Alto)

La pila de matrices


En la función display() se encuentran las llamadas a dos funciones de matrices que todavía no han sido comentadas. Se trata de glPushMatrix() y glPopMatrix(). Para comprender su funcionamiento, primero se va a experimentar que es lo que ocurre cuando no están dichas llamadas. Para ello se comentan en la función display() ambas llamadas:
void display(void) {
...
// glPushMatrix();
...
glTranslatef(0.0, 0.0, .5);
...
// glPopMatrix();
glutSwapBuffers();
}

La razón de este movimiento es que en la función display está incluida una llamada a glTranslatef() que se utiliza para posicionar uno de los objetos. Como se ha explicado anteriormente, las funciones de traslación multiplican la matriz actual por una matriz de traslación creada con los argumentos que se le pasan, por tanto, sucesivas llamadas a la función display() provocan sucesivas multiplicaciones de la matriz actual con el efecto que se observa de incrementar la traslación.
Para solucionar este problema OpenGL dispone de unos stacks o pilas de matrices, que permiten almacenar y recuperar una matriz anterior. Aunque OpenGL dispone de pilas para las matrices GL_MODELVIEW y GL_PROJECTION, sólo se suele utilizar la pila de GL_MODELVIEW.
Una pila es un almacén con funcionamiento LIFO, el último en entrar es el primero en salir, por lo que suele comparar a una pila de platos en la que sólo se puede dejar uno encima de la pila o coger el superior que es el último depositado. La pila de matrices tiene el mismo funcionamiento sustituyendo los platos por matrices. La matriz superior de la pila es sobre la que se aplican las distintas transformaciones, multiplicándola por la matriz que generan las distintas funciones.
La función glPushMatrix() realiza una copia de la matriz superior y la pone encima de la pila, de tal forma que las dos matrices superiores son iguales. En la figura 1 se observa la pila en la situación inicial con una sola matriz, al llamar a la función glPushMatrix() se duplica la matriz superior. Las siguientes transformaciones que se realizan se aplican sólo a la matriz superior de la pila, quedando la anterior con los valores que tenía en el momento de llamar a la función glPushMatrix().
La función glPopMatrix() elimina la matriz superior, quedando en la parte superior de la pila la matriz que estaba en el momento de llamar a la función glPushMatrix().

Dibujando un rastro

Una característica de Logo es que la tortuga al avanzar va dibujando el camino por el que ha pasado. Hasta ahora la aplicación va transformando las coordenadas del objeto para situarlo en la nueva posición según las instrucciones introducidas pero no muestra la ruta seguida.
Para mostrar la ruta es necesario almacenar los puntos por los que pasa la tortuga. El rastro consistirá en una línea que una estos puntos.
Necesitaremos realizar tres operaciones: calcular la coordendas donde se encuentra la tortuga, almacenar dicha coordenada y dibujar el rastro.
Para almacenar los puntos se utiliza una variable para indicar el número de puntos y tres vectores para las coordenadas x, y, z.
int np = 0;
float px [10000];
float py [10000];
float pz [10000];
Para calcular las coordenadas de la tortuga es necesario conocer la matriz de transformación de modelado. Debido a que en OpenGL, la matriz de modelado se almacena junto con la de visualización en la matriz GL_MODELVIEW, es necesario guardar de modo independiente esta matriz de modelado. Para ello definimos la variable mModel, como una variable global, ya que va a ser accedida en distinos puntos de la aplicación: GLdouble mModel[16]
Para operar con la matriz mModel, se cargará en la pila de matrices de GL_MODELVIEW despues de realizar un PushMatrix(), de modo que no altere la matriz actual. En la función main() se inicializa esta matriz con el código:
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glGetDoublev (GL_MODELVIEW_MATRIX, mModel);
glPopMatrix();

MOSTRAR TEXTO
Las instrucciones introducidas se muestran en la ventana MSDOS. Se pueden mostrar en la ventana gráfica. Para ello es necesario cambiar las matrices de transformación. La siguiente función realiza la representación del texto:
void text(GLuint x, GLuint y, GLfloat scale, char* format, ...) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}

miércoles, 26 de septiembre de 2012

Matrices


Matrices

Las matemáticas que hay tras las transformaciones se simplifican gracias a las matrices. Cada una de las transformaciones puede conseguirse multiplicando una matriz que contenga los vértices por una matriz que describa la transformación. Por tanto todas las transformaciones ejecutables con ogl pueden describirse como la multiplicación de dos o más matrices.

El canal de transformaciones

Para poder llevar a cabo todas las transformaciones de, deben modificarse dos matrices: la matriz del Modelador y la matriz de Proyección. OpenGL proporciona muchas funciones de alto nivel que hacen muy sencillo la construcción de matrices para transformaciones. Éstas se aplican sobre la matriz que este activa en ese instante. Para activar una de las dos matrices utilizamos la función glMatrixMode. Hay dos parámetros posibles:

glMatrixMode(GL_PROJECTION);
Activa la matriz de proyección, y
glMatrixMode(GL_MODELVIEW);

Activa la del modelador. Es necesario especificar con que matriz se trabaja, para poder aplicar las transformaciones necesarias en función de lo que se desee hacer.

El camino que va desde los datos “en bruto” de los vértices hasta las coordenadas en pantalla sigue el siguiente camino: Primero, el vértice se convierte en una matriz 1x4 en la que los tres primeros valores son las coordenadas x, y, z. El cuarto número (llamado parámetro w) es un factor de escala, que no se va a usar de momento, usando el valor 1.0. Entonces se multiplica el vértice por la matriz del modelador, para obtener las coordenadas oculares. Éstas se multiplican por la matriz de proyección para conseguir las coordenadas de trabajo. Con esto se eliminan todos los datos que están fuera del volumen de proyección. Estas coordenadas de trabajo se dividen por el parámetro w del vértice, para hacer el escalado relativo. Finalmente, las coordenadas resultantes se mapean en un plano 2D mediante la transformación de la vista.

La matriz del modelador

La matriz del modelador es una matriz 4x4 que representa el sistema de coordenadas transformado que se está usando para colocar y orientar los objetos. Si se multiplica la matriz del vértice (de tamaño 1x4) por ésta se obtiene otra matriz 1x4 con los vértices transformados sobre ese sistema de coordenadas.

OpenGL proporciona funciones de alto nivel para conseguir matrices de translación, rotación y escalado, y además la multiplican por la matriz activa en ese instante, de manera que no hay que preocuparse por ello en absoluto.

Traslación

Imaginemos que se quiere dibujar un cubo con la función de la librería GLUT glutSolidCube, que lleva como parámetro el lado del cubo. Si se escribe el siguiente código:

glutSolidCube(5);

Se obtiene un cubo centrado en el origen (0,0,0) y con el lado de la arista 5. Ahora se quiere mover 10 unidades hacia la derecha (es decir, 10 unidades en el sentido positivo del eje de las x). Para ello se tendría que construir una matriz de transformación y multiplicarla por la matriz del modelador. Ogl nos ofrece la función glTranslate, que crea la matriz de transformación y la multiplica por la matriz que está activa en ese instante (en este caso debería ser la del modelador, GL_MODELVIEW). Entonces el código quedaría de la siguiente manera:

glTranslatef(10.0f, 0.0f, 0.0f);
glutSolidCube(5);

La “f” añadida a la función indica que se usarán flotantes. Los parámetros de glTranslate son las unidades a desplazar en el eje x, y y z, respectivamente. Pueden ser valores negativos, para trasladar en el sentido contrario.

Rotación

Para rotar, tenemos también una función de alto nivel que construye la matriz de transformación y la multiplica por la matriz activa, glRotate. Lleva como parámetros el ángulo a rotar (en grados, sentido horario), y después x, y y z del vector sobre el cual se quiere rotar el objeto. Una rotación simple, sobre el eje y, de 10° sería:
glRotatef(10, 0.0f, 1.0f, 0.0f);

Escalado

Una transformación de escala incrementa el tamaño de nuestro objeto expandiendo todos los vértices a lo largo de los tres ejes por los factores especificados. La función glScale lleva como parámetros la escala en x, y y z, respectivamente. El valor 1.0f es la referencia de la escala, de tal forma que:

glScalef(1.0f, 1.0f, 1.0f);

No modificaría el objeto en absoluto. Un valor de 2.0f sería el doble, y 0.5f sería la mitad. Por ejemplo, para ensanchar un objeto a lo largo de su eje z, de tal forma que quedase cuatro veces más “alargado” en este eje, sería:
glScalef(1.0f, 1.0f, 4.0f);

La matriz identidad

El “problema” del uso de estas funciones surge cuando se tiene más de un objeto en la escena. Estas funciones tienen efectos acumulativos. Es decir, si se quiere preparar una escena como la de la ilustración:

Con una esfera (de radio 3) centrada en (0, 10, 0) y otra centrada en (10, 0, 0), y se escribe el siguiente código (que es incorrecto):

glTranslatef(0.0f, 10.0f, 0.0f);
glutSolidSphere(3.0f, 8, 8);
glTranslate(10.0f, 0.0f, 0.0f);
glutSolidsphere(3.0f, 8, 8);

En este código, se dibuja primero una esfera en (0, 10, 0) como se quiere. Pero después, se está multiplicando la matriz del modelador (que ya estaba transformada para dibujar la primera esfera) por otra matriz de transformación que desplaza 10 unidades hacia la derecha. Por ello la segunda matriz se dibujaría, en (10, 10 ,0), y no en (10, 0, 0), como se pretendía.

Para solventar este problema se debe reiniciar la matriz del modelador a un estado conocido, en este caso, centrada en el origen de nuestro sistema de coordenadas oculares. Para ello se carga en la matriz del modelador la matriz identidad (una matriz 4x4 llena de ceros excepto en la diagonal, que contiene unos). Esto se consigue gracias a la función glLoadIdentity, que no lleva parámetros. Simplemente carga la matriz identidad en la matriz activa en ese instante. El código correcto para el ejemplo anterior quedaría de la siguiente manera:

glTranslatef(0.0f, 10.0f, 0.0f);
glutSolidSphere(3.0f, 8, 8);
glLoadIdentity();
glTranslate(10.0f, 0.0f, 0.0f);
glutSolidsphere(3.0f, 8, 8);  


La matriz de proyección

La matriz de proyección especifica el tamaño y la forma del volumen de visualización. El volumen de visualización es aquel cuyo contenido es el que se representa en pantalla. Está delimitado por una serie de planos de trabajo. De estos planos, los más importantes son los planos de corte, que son los que nos acotan el volumen de visualización por delante y por detrás. En el plano más cercano a la cámara (znear) es donde se proyecta la escena para luego pasarla a la pantalla. Todo lo que está más adelante del plano de corte más alejado de la cámara (zfar) no se representa.

Proyecciones ortográficas

Una proyección ortográfica es cuadrada en todas sus caras. Esto produce una proyección paralela, útil para aplicaciones de tipo CAD o dibujos arquitectónicos, o también para tomar medidas, ya que las dimensiones de lo que representan no se ven alteradas por la proyección.

Una aproximación menos técnica pero más comprensible de esta proyección es imaginar que se tiene un objeto fabricado con un material deformable, y se aplasta literalmente como una pared. Se obtendría el mismo objeto, pero plano, liso. Pues eso es lo que se vería por pantalla.

Para definir la matriz de proyección ortográfica y multiplicarla por la matriz activa (que debería ser en ese momento la de proyección, GL_PROJECTION), se utiliza la función glOrtho, que se define de la siguiente forma:

glOrtho(limiteIzquierdo, limiteDerecho, limiteAbajo, limiteArriba, znear, zfar)

Siendo todos flotantes. Los valores de znear y zfar no son las posiciones de esos planos en el espacio 3D. Representan la distancia desde el centro de proyección, con valor positivo hacia delante y negativo hacia atrás. Con esto simplemente se acota  lo que será¡ el volumen de visualización (un cubo).

Por ejemplo, la ilustración es un render de un coche con proyección ortográfica, visto desde delante.

El código utilizado para esta proyección ha sido:

glOrtho(-0.5f, 0.5f, -0.5f, 0.5f, 0.01f, 20.0f);

Proyecciones perspectivas

Una proyección en perspectiva reduce y estira los objetos más alejados del observador. Es importante saber que las medidas de la proyección de un objeto no tienen por qué coincidir con las del objeto real, ya que han sido deformadas.

El volumen de visualización creado por una perspectiva se llama frustum. Un frustum es una sección piramidal, vista desde la parte afilada hasta la base.

Se puede definir esta proyección utilizando la función glFrustum. Pero existe otra función de la librería GLU llamada gluPerspective que hace el proceso más sencillo. Se define de la siguiente forma:

Void gluPerspective(angulo, aspecto, znear, zfar);

Los parámetros de gluPerspective son flotantes y definen las características mostradas en la ilustración, el ángulo para el campo de visión en sentido vertical, el aspecto que es la relación entre la altura (h) y la anchura (w) y las distancias znear y zfar de los planos que acotan el fustrum al observador. Los valores de znear y zfar no son las posiciones de esos planos en el espacio 3D, representan la distancia desde el centro de proyección, con valor positivo hacia delante y negativo hacia atrás.
La ilustración muestra la escena del coche de la sección anterior, esta vez con una proyección en perspectiva:

El código utilizado para definir la proyección ha sido:

gluPerspective(45.0f,(GLfloat)(width/height),0.01f,100.0f);

Se usan 45° de ángulo, la relación entre el ancho y alto de la pantalla (width y height son el ancho y alto actual de la ventana) y las distancias a los planos de corte znear y zfar son 0.01 y 100 respectivamente.

martes, 25 de septiembre de 2012

Transformaciones geometricas

Hay que tener claro que no es lo mismo mover el objeto que mover la cámara. Si se mueve la cámara 3 unidades para atrás y se mueve el objeto 3 unidades para adelante la visión que se produce es la misma pero la escena ya no es la misma.
   
Las definiciones de las funciones son:

void glTranslate{fd}(TYPE x, TYPE y, TYPE z);
Multiplica la matriz actual por una matriz de traslación que mueve el objeto.s


void glRotate{fd}(TYPE angle,TYPE x, TYPE y, TYPE z);
Multiplica la matriz actual por una matriz de rotación que rota el objeto en la dirección de las agujas del reloj sobre el radio de origen en el punto x,y,z.



void glScale{fd}(TYPE x, TYPE y, TYPE z);
Multiplica la matriz actual por una matriz que cambia el tamaño del objeto a lo largo de los ejes. Las coordenadas x, y, z de cada objeto es multiplicada por los parámetros x, y, z.

lunes, 24 de septiembre de 2012

Proyeccion en OpenGL

Es  necesario activar la matriz e inicializarla mediante las órdenes OpenGL:

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

La proyección define el volumen del espacio que va a utilizarse para formar la imagen; en el caso de la proyección perspectiva este volumen es una pirámide truncada o frustum. Por lo tanto, en esta proyección se produce un efecto tamaño - distancia y es la proyección más usada en animación por ordenador o simulación visual, donde se requiere un alto grado de realismo. El frustum de visualización se define en OpenGL de la forma siguiente:

void glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,

GLdouble near, GLdouble far)

Dónde los parámetros left, right, bottom, top, near y far definen el frustum tal y como se muestra en la figura siguiente:

Tal y como se muestra en la figura, el frustum no tiene porqué ser simétrico respecto al eje Z, ya que es posible utilizar valores distintos para left y right, o para bottom y top.

La especificación de una proyección perspectiva mediante glFrustum puede resultar complicada debido a que la forma de definición no resulta intuitiva. En lugar de esta orden, podemos utilizar la rutina de la librería de utilidades de OpenGL gluPerspective. Esta rutina permite especificar el volumen de la vista de forma diferente, utilizando el ángulo de visión sobre el plano XZ (fovy) y el ratio de la anchura respecto a la altura (aspect). Mediante estos parámetros es posible determinar el volumen de la vista, tal y como se muestra en la figura siguiente: 
Esta forma de definir la proyección resulta más intuitiva. La sintaxis de la rutina gluPerspective es la siguiente:

void gluPerspective (GLdouble fovy, GLdouble aspect, GLdouble near, GLdouble far)

Cuando utilicemos la rutina gluPerspective tendremos que tomar precauciones con respecto a los valores de fovy y near. Una mala elección de dichos valores puede producir deformaciones en la imagen similares a las aberraciones ópticas habituales en las lentes fotográficas (v.g. efecto “ojo de pez”).

Otra forma de definir la manera en que una cámara sintética observa una escena es mediante dos posiciones en el espacio: la del punto de interés o punto al que la cámara está enfocando, y la del punto de vista o punto dónde se encuentra situada la cámara. Esta forma de definir la transformación de la vista es la que utiliza la orden de la librería de utilidades de OpenGL gluLookAt. La sintaxis de la orden es la siguiente:

gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez,

GLdouble centerx, GLdouble centery, GLdouble centerz,

GLdouble upx, GLdouble upy, GLdouble upz);

Donde los parámetros eyex, eyey, eyez indican la posición del punto de vista; centerx, centery, centerz especifican el punto de interés y upx, upy, upz la dirección tomada como “arriba”, o inclinación de la cámara

La proyección ortográfica define un volumen de la vista cuya geometría es la de un paralelepípedo rectangular (o informalmente, una “caja”). A diferencia de la proyección perspectiva, la distancia de un objeto a la cámara no influye en el tamaño final del mismo en la imagen. Este tipo de proyecciones son comunes en aplicaciones de diseño asistido por ordenador, ya que las medidas sobre la imagen son proporcionales a las reales de acuerdo a un determinado factor de escala. Entre las proyecciones ortográficas más comunes en este tipo de sistemas cabe destacar la proyección ortográfica (planta, alzado y perfil) y la proyección isométrica. La caja de visualización se define en OpenGL de la forma siguiente:

void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,

GLdouble near, GLdouble far)

Dónde los parámetros left, right, bottom, top, near y far definen la caja tal y como se muestra en la figura siguiente:
 

jueves, 13 de septiembre de 2012

Generacion de lineas rectas


LINEA

Es el medio gráfico fundamental para representar las formas que nos rodean y las ideas, creando un lenguaje que no necesita palabras. Es el elemento visual más importante del dibujo. Tiene la facultad de transmitir sensaciones ya sea por su forma o por su disposición, solas o agrupadas.

 Líneas rectas: Expresan robustez y rigidez
 Líneas curvas: Sugiere movimiento, vitalidad, suavidad, delicadeza.
 Líneas horizontales: Expresan calma, reposo, tranquilidad, peso, estabilidad. Hacen las   cosas más anchas y extensas.
 Líneas verticales: Nos transmiten fuerza, orden, equilibrio, movimiento ascendente o descendente, elegancia, espiritualidad. Producen el fenómeno visual de alargar las cosas.
 Líneas oblicuas: Expresan inestabilidad, acción, caída, caos, desorden, confusión, sensación de profundidad y alejamiento.
 Líneas quebradas: Producen el efecto de incertidumbre,  indecisión. Una sensación similar a la ro-tura, la fragmentación.
 Líneas radiales o concurrentes: Sugieren luminosidad, explosión, asombro, dispersión, profundidad.

ALGORITMO DDA PARA GENERACION DE RECTAS

Este Algoritmo sirve para Generar Una Línea Recta, y Para eso Hace Uso de La pendiente Y de los Incrementos en X, Y.
Como todos saben Open GL es una herramienta que nos facilita mucho la generación de gráficos por computadora. Aquí aplicamos conocimientos matemáticos, usando Open GL para generar rectas, circunferencias, elipses, etc. El Algoritmo DDA es un algoritmo de línea de conversión de rastreo que se basa en el cálculo ya sea en el incremento de X o en el incremento de Y. La finalidad de este algoritmo es determinar los valores enteros correspondientes más próximos a la trayectoria de la línea para la otra coordenada.

void DDA(int x0,int y0,int xFin,int yFin){
int dx = xFin - x0, dy = yFin - y0, steps, k;
float xIncremento, yIncremento;
float x = x0, y = y0;
if (fabs (dx) > fabs (dy))
steps = fabs (dx); /* |m|<1>
else
steps = fabs (dy); /* |m|>=1 */
xIncremento=float(dx)/float (steps);
yIncrement = float (dy) / float (steps);
setPixel (round (x), round (y));
for (k = 0; k <>{
x += xIncremento;
y += yIncremento;
setPixel (round (x), round (y));
}

}

ALGORITMO DE BRESENHAM PARA TRAZAR LÍNEAS

El algoritmo de Bresenham es un algoritmo creado para dibujar rectas en los dispositivos de gráficos rasterizados, como por ejemplo un monitor de ordenador, que determina qué pixeles se rellenarán, en función de la inclinación del ángulo de la recta a dibujar. El algoritmo de Bresenham sirve para trazar una línea entre dos puntos.

void Bres(int x0,int y0,int xFin,int yFin){
int dx = fabs(xFin - x0),
dy = fabs(yFin - y0);
int p = 2 * dy - dx;
int dosDy = 2 * dy,
dosDyMenosDx = 2 * (dy - dx);
int x, y;
if (x0 > xFin) {
x = xFin;
y = yFin;
xFin = x0;
}
else {
x = x0;
y = y0;
}
setPixel (x, y);
while (x <>
x++;
if (p <>
p += dosDy;
else {
y++;
p += dosDyMenosDx;
}

setPixel (x, y);

}

}

CIRCUNFERENCIA

Se conoce como circunferencia a la línea cerrada de formato curva y apariencia plana en la cual los puntos resultan equidistantes del punto central que se localiza en el mismo plano. Esta distancia que separa al conjunto de puntos y al área central se conoce como radio, mientras que el segmento de recta que compone un par de radios alineados recibe el nombre de diámetro.

ALGORITMO DE BRESENHAM PARA TRAZAR CIRCUNFERENCIAS

Los dos procedimientos planteados en esta sección utilizan demasiadas operaciones, sobre todo de aritmética de punto flotante, cuando deseamos trazar cientos de círculos, comenzamos a pensar en que debemos encontrar una forma más eficiente de hacerlo.

Estamos de acuerdo en que si somos capaces de trazar el circulo en el origen, moverlo de manera en que su centro quede ubicado en (xc; yc) implica simplemente sumar xc a todas las coordenadas x y sumar yc a todas