jueves, 26 de abril de 2012

UNIDAD IV







COMO SE AGREGAN LOS RELLENOS DE POLIGONOS EN OPENGL

Dentro del par glBegin, glEnd solo pueden ir instrucciones OpenGL para definir objetos tales como vértices, y colores (existen otras más complejas como normales y materiales) y no transformaciones ni cambios de estado (diferentes a los especificados), adicionalmente dentro del par pueden ir instrucciones de programación del lenguaje tales que ciclos, condicionales, llamados a funciones, etc.

GlBegin (GL_POLYGON)’;
glColor3f (1.0, 0.0, 0.0); // rojo
For (int i=0; i<10; i++){
glVertex3f (1.0/i, i*i, 0.0);
}
glColor3f (0.0, 1.0, 0.0); // verde
glVertex3f (1.0, 0.0, 0.0);
glColor3f (0.0, 0.0, 1.0); // azul
glVertex3f (1.0, 1.0, 0.0);
glEnd();

 La función glColor define el color de rellenado actual y lleva como parámetros los valores de las componentes RGB del color deseado y, opcionalmente, un cuarto parámetro con el valor alpha. Estos parámetros son flotantes y se mueven en el rango [0.0, 1.0].

glColor3 [f] [v]: para cambiar el color actual de dibujo, puede estar en bloque glBegin/glEnd

CONCEPTOS
CLASICAS: ILUMINACION LOCAL
ILUMINACION LOCAL.- La iluminación del Local es tan importante como la transparencia del mismo, ya que tenemos que lograr que sea una vitrina de exposición de lo que significa "la marca".
Debe tener en cuenta que la iluminación del local se divide en diferentes sectores.
  1. Las carteleras, tanto internas como externas, deben tener buena iluminación, sean Back-light (Transiluminadas) o Front-Light (iluminadas de frente).
  2. Iluminación de Barra de expendio, Caja de cobro y Vitrinas de exposición: Debe ser pareja, no alterando los colores naturales de los materiales, para que el ambiente sea acogedor.
  3. Mesas o Privados, ahí es donde la iluminación debe crear una atmósfera más íntima, donde la gente se sienta cómoda para compartir un momento agradable, de esparcimiento y degustación.
  4. La iluminación, ayuda a la escenografía planteada para resaltar aspectos en lo que sé desea destacar, ya sea una característica arquitectónica o un material representativo.
CALCULOS DE ILUMINACION POR VERTICES.- Para poder aplicar iluminación necesitamos asociar a cada vértice de nuestro objeto un vector normal asociado. Cuando tenemos la normal calculada tenemos que normalizarla, o sea, dividir ese vector por su propio modulo para que sea unitario, pero también podemos hacer que se encargue la OpengGl activando la normalización, con glEnable GL_NORMALIZE

POSTERIOR RELLENO DE TRIÁNGULOS.- 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. Otras variables como la coordenada de profundidad z o las coordenadas de textura sufren el mismo proceso de interpolación lineal, fácilmente reproducible por hardware.

RENDERIZADO EN TIEMPO REAL.- Se presenta un algoritmo para representar los objetos de materiales transparentes con superficies ásperas en tiempo real, bajo la iluminación de todos los de frecuencia distantes. Las superficies rugosas causan dispersión amplia como la luz entra y sale de los objetos, lo que complica considerablemente la prestación de dichos materiales. Se presentan dos contribuciones a la aproximación de los eventos de dispersión sucesivas en las interfaces, debido a la refracción en bruto

REALISTAS: ILUMINACION GLOBAL 

TRAZADO DE RAYOS.- El raytracing o trazado de rayos es un algoritmo para síntesis de imágenes tridimensionales. En el algoritmo Ray Casting se determinan las superficies visibles en la escena que se quiere sintetizar trazando rayos desde el observador (cámara) hasta la escena a través del plano de la imagen. Se calculan las intersecciones del rayo con los diferentes objetos de la escena y aquella intersección que esté más cerca del observador determina cuál es el objeto visible.
RADIOSIDAD.- La radiosidad es un conjunto de técnicas para el cálculo de la iluminación global que tratan de resolver el problema básico de la renderizacion de la forma más realista posible en el campo de los gráficos 3D por computadora. Dicho problema es:
El transporte de la luz sólo se puede modelar de forma óptima considerando que cada fuente luminosa emite un número enorme de fotones, que rebotan al chocar contra una superficie describiendo una cantidad de trayectorias imposibles de simular en un computador.

 CALCULOS DE ILUMINACION POR PIXEL.- La iluminación por píxel en tiempo real es una tecnología revolucionaria ofrecida como primicia por NVIDIA Shading Rasterizer. La iluminación dinámica a nivel de píxel libera a los desarrolladores de las restricciones de otros sistemas de iluminación y pone a su alcance toda una gama de sofisticados efectos. 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 (p.ej. todo un triángulo). Aceleramos el proceso de síntesis.  Correcto si se verifica: Fuente de luz en el infinito. Observador en el infinito. 

SOMBREADO CONSTANTE O PLANO 

UN CALCULO PARA TODO EL POLIGONO.- Obtenemos una intensidad  que aplicamos a un conjunto de puntos de un objet.
  • ·         Aceleramos el proceso de síntesis
  • ·         Correcto si se verifica
  • ·         Fuente de luz en el infinito
  • ·         Observador en el infinito
  • ·         El polígono representa una superficie plana real del objeto que se modela y no es una aproximación de un objeto curvo.
INTERPOLACION DE INTENCIDADES (GOURAUD)

INTERPOLA INTENSIDADES.-  Se basa en la interpolación de intensidad o color
Considera que facetas planas vecinas proceden deaproximar una superficie curva (salvo que se  declare una arista real entre ambas)
      *Elimina en gran medida las discontinuidades de iluminación
     *Es sencilla, pero produce peores resultados en objetos con brillos especulares que el método de Phong
      *Implementado en OpenGL
 
INTERPOLACION DE NORMALES (PHONG) 
Se basa en la interpolación de la dirección de la normal, calculada de la misma forma que antes. Igual que en Gouraud, se interpola a lo largo de cada línea de barrido, entre los puntos inicial y final, interpolados a su vez de los valores de los vértices de la arista.
Captura mejor los brillos especulares en el medio de facetas planas (Gouraud los puede omitir). Produce mejores resultados, a un coste computacional mayor (hay que incrementar la dirección de la normal en tres direcciones, normalizarla y calcular la ecuación de sombreado encada punto) Si el coeficiente de reflexión especular es pequeño, los resultados no difieren tanto (se pueden combinar objetos sombreados por ambos métodos en una escena).


RAYTRACING.-El raytracing o trazado de rayos es un algoritmo para síntesis de imágenes tridimensionales. Propuesto inicialmente por Turner Whitted en 1980, está basado en el algoritmo de determinación de superficies visibles de Arthur Appel denominado Ray Casting (1968).
En el algoritmo Ray Casting se determinan las superficies visibles en la escena que se quiere sintetizar trazando rayos desde el observador (cámara) hasta la escena a través del plano de la imagen. Se calculan las intersecciones del rayo con los diferentes objetos de la escena y aquella intersección que esté más cerca del observador determina cuál es el objeto visible.
El algoritmo de trazado de rayos extiende la idea de trazar los rayos para determinar las superficies visibles con un proceso de sombreado (cálculo de la intensidad del píxel) que tiene en cuenta efectos globales de iluminación como pueden ser reflexiones, refracciones o sombras arrojadas.
 

BUFFER DE PROFUNDIDAD.- Es la parte de la memoria de un adaptador de video encargada de gestionar las coordenadas de profundidad de las imágenes en los gráficos en tres dimensiones (3-D), normalmente calculados por hardware y algunas veces por software. Es una de las soluciones al problema de visibilidad, que es el problema de decidir qué elementos de una escena renderizada son visibles y cuales ocultos. El algoritmo del pintor es otra solución común, aunque menos eficiente, también puede manejar escenas con elementos no opacos. El Z-buffering también se conoce como buffering de profundidad.
Cuando un objeto es dibujado por una Tarjeta gráfica 3D, la profundidad del píxel generado (coordenada z) se almacena en un buffer de datos (el z-buffer). Este buffer se suele distribuir como un array de 2 dimensiones (x-y) con un elemento por cada pixel de la pantalla. Si algún otro objeto de la escena se tiene que renderizar en el mismo pixel, la tarjeta gráfica compara las dos profundidades y elige el más cercano al observador. La profundidad elegida es entonces salvada en el z-buffer, reemplazando a la antigua. Al final, el z-buffer permitirá a la tarjeta gráfica reproducir correctamente la percepción de la profundidad normal: los objetos cercanos ocultan a los más lejanos.

STENCIL BUFFER.- Stencill Buffer 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.
Stencil buffer es similar al buffer de profundidad en que los dos son colección de planos de bit que no se pueden mostrar.

LUZ AMBIENTE.- 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. Si se sigue este segundo enfoque, se puede postular una intensidad ambiente en cada punto del ambiente. Por lo tanto, iluminación ambiente se caracteriza por una intensidad Ia que es idéntica en cada punto de la escena.
SPOTLIGTHS.- 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 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, una computación que es una parte significativa del cálculo del sombreado. 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.

INTENCIDAD COMPLETA.- La intensidad completa exclusivamente Por efectos de iluminación es la siguiente:










martes, 17 de abril de 2012

ELIPSES Y CIRCULOS

FUNCIONES OpenGL PARA CURVAS

Las rutinas para generar curvas básicas, como círculos y elipses, no están incluidas como funciones primitivas en la biblioteca OpenGL básica. Pero esta biblioteca sí que contiene funciones para dibujar spunes de Bézier, que son polinomios que se definen mediante un conjunto de puntos discreto. Y la utilidad OpenGL (GLU, OpenGL Ulility) tiene rutinas para cuádricas tridimensionales, como esferas y cilindros, además de rutinas para generar B-splines racionales, que son una clase genérica de Splines en la que están incluidas las curvas de Bézier, más simples.

Otro método que podemos utilizar para generar la gráfica de una curva simple consiste en aproximarla ulizando una polilinea. Basta con localizar un conjunto de puntos a lo largo del trayecto de la curva y conectar dichos puntos mediante segmentos de linea recta. Cuantas más secciones lineales incluyamos en la polilinea. más suave será la apariencia de la curva.

ALGORITMOS PARA LA GENERACION DE CIRCULOS

Puesto que el círculo es un componente muy frecuentemente utilizado en dibujos y gráficas, muchos paquetes gráficos incluyen un procedimiento para generar círculos completos o arcos circulares. Asimismo, en ocasiones hay disponible una función genérica en las bibliotecas gráficas para mostrar diversos tipos de curvas, incluyendo círculos y elipses.

La forma del circulo es similar en cada uno de los cuadrantes. Por tanto, si determinamos las posiciones de la curva en el primer cuadrante, podemos generar la sección circular del segundo cuadrante del plano i observando que ambas secciones son simétricas con respecto al eje y. Y la secciones circulares de los cuadrantes tercero y cuarto pueden obtenerse a partir de las secciones de los dos primeros cuadrantes considerando la simetría con respecto al eje v.

ALGORITMO DEL PUNTO MEDIO PARA GENERACIÓN DE CÍRCULOS

1.    Introducir el radio r y el centro del círculo (xv,yt) y luego establecer las coordenadas para el primer punto de la circunferencia de un círculo centrado en el origen mediante la fórmula

2.    Calcular el valor inicial del parámetro de decisión

3.    Para cada posición xy comenzando en k = 0, realizar la siguiente comprobación. Si pk < 0, el siguiente punto a lo largo de un círculo centrado en (0,0) será {xk+iJyk) y, P^=Pt+2xktl+\

4.    Determinar los puntos simétricos en los otros siete ociantes.

5.    Mover cada posición de píxel (x, y) calculada hasta la trayectoria circular centrada en (xc,yc) y dibujar los valores de coordenadas: x=x+xc , y = y+yc

6.    Repetir los Pasos 3 a 5 hasta que x > y.


ALGORITMOS DE GENERACIÓN DE ELIPSES

En termines simples, una elipse es un circulo alargado. También podemos escribir una elipse como un circulo modificado cuyo radio varía desde un valor máximo en una dirección hasta un valor mínimo en la dirección perpendicular.

Formas paramétricas

La ecuación paramétrica de una elipse con centro en (H,K) y siendo el semieje mayor y b el menor, es:


con no es el ángulo θ del sistema de coordenadas polares con origen en el centro de la elipse (tampoco es el ángulo del sistema de coordenadas polares con origen en algún foco de la elipse). La relación entre y θ es

La ecuación paramétrica de una elipse con centro en en la que el parámetro sea concordante con el ángulo polar respecto al centro desplazado es:


con . El parámetro es el ángulo de un sistema polar cuyo origen está centrado en .

Programa Carro

Codigo
#include <GL/glut.h>
GLfloat TrasX=0.0f;
GLfloat TrasY=0.0f;
GLfloat TrasZ=0.0f;
GLint ancho=400;
GLint alto=400;
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, 1, 10);
    glMatrixMode(GL_MODELVIEW);
    ancho = width;
    alto = height;
}
void Piso(void)
{
    glColor3f(0.25f, 0.25f, 0.25f);
 glScalef(5.0f,0.0f,5.0f);
   
 glBegin(GL_QUADS);      
    glVertex3f( 2.5f,-1.0f, -1.0f);
    glVertex3f( 2.5f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glEnd();
}
void carro(void)
{
   glColor3f(1.0f, 0.0f, 0.0f);
glTranslatef(0.0f, -2.0f, 0.0f);
glBegin(GL_POLYGON); //carro
glVertex3f(-1.5f,0.5f, -2.0f);
glVertex3f( 3.5f,0.5f, -2.0f);
glVertex3f(3.5f,2.0f, -2.0f);
glVertex3f(2.0f,2.0f, -2.0f);
glVertex3f(1.f,3.0f, -2.0f);
glVertex3f(-0.5f,3.0f, -2.0f);
glVertex3f(-1.5f,2.0f, -2.0f);
glEnd();
}
void display()
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f, -2.0f, -5.0f);
glRotatef(10, 1.0f, 0.0f, 0.0f);
glRotatef(10, 0.0f, 1.0f, 0.0f);
// dibuja piso
Piso();
// dibuja rueda
glLoadIdentity();
glTranslatef(3.0f,-1.5f,-1.0f);
glTranslatef(TrasX,TrasY,TrasZ);
glColor3f(0.0f, 0.0f, 0.0f);
glutSolidSphere(0.5f, 16, 16);



//dibuja 2da rueda
glLoadIdentity();
glColor3f(0.0f, 1.0f, 1.0f);
glLoadIdentity();
glTranslatef(TrasX,TrasY,TrasZ);
carro();
glLoadIdentity();
glTranslatef(-.5f,-1.5f,-1.0f);
glTranslatef(TrasX,TrasY,TrasZ);
glColor3f(0.0f, 0.0f, 0.0f);
glutSolidSphere(0.5f, 16, 16);
glFlush();
glutSwapBuffers();
}
void init()
{
    glClearColor(1,1,1,1);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}
void idle()
{
    display();
}

void keyboard(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 'p':
    case 'P':
  hazPerspectiva=1;
  reshape(ancho,alto);
 break;
    case 'o':
    case 'O':
  hazPerspectiva=0;
  reshape(ancho,alto);
 break;
    case 'a':
    case 'A':
  TrasX-=.10;
 break;
    case 's':
    case 'S':
  TrasX+=.10;
                break;
    }
}

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




CORRIDA