viernes, 27 de abril de 2012

UNIDAD 4




AGREGAR UN SOMBREADO A UN POLIGONO EN OPENGL

Es un método manejado por OpenGl que es de tal uso para rellenar de color los polígonos que se estén realizando en el ámbito de la graficacion.
Antes que nada se especifica haciendo uso de la función glShadeModel. Si el parámetro es GL_FLAT, ogl rellenará los polígonos con el color activo en el momento que se definió el último parámetro; si es GL_SMOOTH, ogl rellenará el polígono interpolando los colores activos en la definición de cada vértice.
 Este código es un ejemplo de GL_FLAT: 

glShadeModel(GL_FLAT);


glBegin(GL_TRIANGLES);  


      glColor3f(1.0f, 0.0f, 0.0f);  // activamos el color rojo


      glVertex3f(-1.0f, 0.0f, 0.0f);


      glColor3f(0.0f, 1.0f, 0.0f);  // activamos el color verde


      glVertex3f(1.0f, 0.0f, 0.0f);


      glColor3f(0.0f, 0.0f, 1.0f);  // activamos el color azul


      glVertex3f(0.0f, 1.0f, 0.0f);


glEnd();
  
Tecnicas de sombreado clasicas y avanzadas

Clásicas: Iluminación local.
Luces que no son extensas, como las reales, sino inextensas, puntuales. Y, por añadidura, se relacionan con los objetos como mónadas aisladas, sin tener en cuenta la interacción entre ellos. Esto explica lo artificioso de muchas de las técnicas que se describirán más adelante y que buscan compensar estas limitaciones.

Cálculos de iluminación por vértices
Para aplicar iluminaciona un objeto necesitamos asociar un vector normal a cada vertice del objeto.  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 el comando glEnable GL_NORMALIZE o desactivarla con glDisable GL_NORMALIZE.
El usar GL_NORMALIZE dependerá de nuestra aplicación ya que si forzamos a que sea OpenGl el que las utilice se ralentiza por que le estamos obligando a hacer mas cálculos de los que debe.
Para definir las normales en opengl utilizaremos la función glNormal3f(X,Y,Z) por ejemplo para definir una cara con 4 vértices la definiremos de la siguiente manera:
GlBegin GL_QUADS
glNormal3f nX,nY,nZ
glvertex3f x,y,z
glvertex3f x,y,z
glvertex3f x,y,z
glvertex3f x,y,z
glEnd

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. Una vez se han generado los triángulos, en la pipeline existen dos partes claramente diferenciadas: una primera etapa operaciones realizadas sobre cada uno de los vértices, y después de que éstos se proyecten sobre la ventana, entonces comienza una segunda fase de cálculos realizados para cada pixel cubierto por triángulos.


Realistas: 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.


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. Esto no quiere decir que no sean útiles para un gran número de casos, y es muy importante calibrar adecuadamente que es lo que se necesita, pues puede muy bien ocurrir que un cálculo local proporcione imágenes relativamente esquemáticas pero más adecuadas para la representación de un proyecto.


Trazado de rayos
El trazado de rayos computa la interacción de la luz desde un punto de vista determinado y es particularmente adecuado para superficies reflectantes. Puede utilizarse como propiedad especifica de un determinado material. 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 ),

Radiosidad
Está basado en principios generales que se pueden encontrar en un manual general sobre rendering. En el estadio inicial la escena consta de dos tipos de objetos: objetos que emiten luz y objetos que reciben luz. A partir de aquí, en una primera vuelta, se computa la luz que recibe cada objeto o, en una aproximación más exacta, cada parte de un objeto, según una subdivisión cuya densidad puede precisarse en sucesivas aproximaciones.


Cálculos de iluminación 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
Sombreado Constante o plano. 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. 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
 Obtenemos una intensidad que aplicamos a un conjunto de puntos de un objeto 
  *Aceleramos el proceso de síntesis
  *Correcto si se verifica.
  * Fuente de luz en el infinito
  *Observador en el infinito

Modelo de Reflexión Phong 
El modelo de reflexión de Phong es eficiente y suficientemente aproximado a la realidad física para producir buenas imágenes, bajo una variedad de condiciones de luz y propiedades de materiales. Apoya los tres tipos de interacciones material-luz: ambiente, difusa y especular. Si se tiene un conjunto de fuentes puntos, con componentes independientes para cada uno de los tres colores primarios para cada uno de los tres tipos de interacciones material-luz.

Ray Tracing 
En muchas formas, 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 Stencil. 
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. Del mismo modo que el buffer de profundidad asocia a cada píxel de la ventana un valor de profundidad, el stencil buffer asocia su propio valor a cada píxel mostrado. Cuando el buffer de profundidad esta activado los valores de profundidad son usados para aceptar o rechazar fragmentos, del mismo modo los valores de Stencil buffer son usados para aceptar o rechazar fragmentos.

Buffer de Acumulacion
 Normalmente se usa un buffer de acumulación para unir las 2 imágenes 


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. 

 Fuentes de Luz
La luz puede dejar una superficie mediante dos procesos fundamentales:
*  Emisión propia
* Reflexión

Luz Ambiente
La 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.

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. Se puede usar un cono cuyo ápice está en ps, apuntando en la dirección ls, y cuyo ancho está determinado


por el ángulo θ.
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



lunes, 16 de abril de 2012

TAREA CIRCULO Y ESFERA


ESFERA

Para una esfera como sabemos en coordenadas cartesianas se es requerido de un radio r el cual esta centrado en el origen de coordenadas de los puntos (x,y,z) los cuales deben de desarrollarse en las siguientes ecuaciones las cuales se encuentran escritas de esta  forma debido a que es para presentarla de manera paramétrica y hace uso de los angulos de latitud y longitud.


Elipsoide
tratandose de una superficie elipsoidal se puede describir como una ampliación de la superficie esférica, en la donde el radio en ires direcciones perpendiculares entre sí puede tener valores diferentes. La representación cartesiana de los puntos de la superficie de un elipsoide centrado en el origen es:
Una representación paramélrica de un elipsoide en función del ángulo de la latitud 0 y del ángulo de la longitud 0 que a continuacion se muestra es:

x = r eos 0 eos ft  -7i/2 <<p<7V/2

y = t\ eos 0 sin ft - k<6<k

Z = r. Sin 0

Un objeto con forma de donut(dona) se denomina toro. Muy a menudo se describe como la superficie generada al hacer girar un círculo o una elipse alrededor de un eje coplanario que es externo a la cónica. 



lunes, 26 de marzo de 2012

UNIDAD 3 CONCEPTOS


TRABAJO1
Como repaso de las unidades anteriores se nos mencionan los tipos de transformaciones existentes en OpenGL, a continuacion se nos da la definicion de cada una:
·  Proyección: Trasforman una escena 3d “abstracta”, en una imagen plana que puede ser visualizada en una pantalla.
·         Viewport: Ajustan el producto de la proyección a las dimensiones de un rectángulo contenedor (ventana).
De vista: o conocida tambien como ortograficanQue definen y afectan la posición desde la cual se visualizan las escenas tridimensionales. Pero para poder ajustar la proyección ortográfica se puede hacer uso del siguiente grupo de funciones:
glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);
Esta función permite controlar los parámetros del volumen de vista izquierdo, derecho, abajo, arriba, cerca y lejos. Hay que recordar que debido a que no se posee percepción de profundidad en este modo el valor del volumen deberá corresponder en la mayoría de los casos a un volumen suficientemente grande para contener los objetos de la escena.

·Modelado: Sirven para manipular los objetos en la escena, permitiendo trasladarlos, rotarlos y deformarlos (escalarlos).
·  Modelo-Vista: Son la combinación de las dos transformaciones anteriores, que desde un punto de vista práctico son semejantes.
· Ortográfica: este permite ajustar la proyección ortográfica de lo cual utiliza el siguiente grupo de funciones:
glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);
Esta función permite controlar los parámetros del volumen de vista izquierdo, derecho, abajo, arriba, cerca y lejos. Hay que recordar que debido a que no se posee percepción de profundidad en este modo el valor del volumen deberá corresponder en la mayoría de los casos a un volumen suficientemente grande para contener los objetos de la escena.
·       Perspectiva: Existen dos manera de manejar la proyección en perspectiva, a través de de una función gl o mediante la librería glu (una tercera puede ser realizar los cálculos de la matriz “manualmente”. En el primer caso:
glFrustrum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

viernes, 23 de marzo de 2012

ROTACIÓN EN UN SOLO PUNTO

A CONTINUACIÓN SE MUESTRA EL CÓDIGO PARA PODER ROTAR EN UN SOLO PUNTO LA PELOTA EN ESTE CÓDIGO

#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 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 drawCube(void)
{
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_QUADS);       //cara frontal
    glVertex3f(-1.0f, -1.0f,  1.0f);
    glVertex3f( 1.0f, -1.0f,  1.0f);
    glVertex3f( 1.0f,  1.0f,  1.0f);
    glVertex3f(-1.0f,  1.0f,  1.0f);

    glEnd();

    glColor3f(0.0f, 1.0f, 0.0f);

    glBegin(GL_QUADS);       //cara trasera
    glVertex3f( 1.0f, -1.0f, -1.0f);
    glVertex3f(-1.0f, -1.0f, -1.0f);
    glVertex3f(-1.0f,  1.0f, -1.0f);
    glVertex3f( 1.0f,  1.0f, -1.0f);

    glEnd();

    glColor3f(0.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara lateral izq
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f, 1.0f,  1.0f);
    glVertex3f(-1.0f, 1.0f, -1.0f);
    glEnd();

    glColor3f(1.0f, 1.0f, 0.0f);
    glBegin(GL_QUADS);       //cara lateral dcha
    glVertex3f(1.0f, -1.0f,  1.0f);
    glVertex3f(1.0f, -1.0f, -1.0f);
    glVertex3f(1.0f,  1.0f, -1.0f);
    glVertex3f(1.0f,  1.0f,  1.0f);
    glEnd();
    glColor3f(0.0f,      1.0f, 1.0f);
    glBegin(GL_QUADS);       //cara arriba
    glVertex3f(-1.0f, 1.0f,  1.0f);
    glVertex3f( 1.0f, 1.0f,  1.0f);
    glVertex3f( 1.0f, 1.0f, -1.0f);
    glVertex3f(-1.0f, 1.0f, -1.0f);
    glEnd();

    glColor3f(1.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara abajo
    glVertex3f( 1.0f,-1.0f, -1.0f);
    glVertex3f( 1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glEnd();
}

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

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);

    glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);
    glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);

    drawCube();

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);
    glRotatef(anguloEsfera, 1.0f, 0.0f, 0.0f);//CODIGO PARA Q SOLO TENGA ROTACION EN UN SOLO PUNTO
    glTranslatef(0.3f, 0.0f, 0.0f);// TRASLADAR EL CUBO A OTRA DISTANCIA EN EL EJE X

    glColor3f(1.0f, 1.0f, 1.0f);
    glutWireSphere(0.5f, 8, 8);

    glFlush();
    glutSwapBuffers();

    anguloCuboX+=0.1f;
    anguloCuboY+=0.1f;
    anguloEsfera+=0.2f;
}

void init()
{
    glClearColor(0,0,0,0);
    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 27:   // escape
      exit(0);
      break;
    }
}

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

martes, 13 de marzo de 2012


Proyección ortogonal
De las proyecciones que hemos manejado mayormente han sido ortogonales. Antes que nada una proyección ortogonal es aquella que nos define un volumen a la vista de un paralepipédo. Las características de esta proyección es que es indispensable el tamaño de los objetos y es independiente de la distancia a la que este el observador de la imagen.
ejemplo




Proyeccion perspectiva
Esta proyeccion da la sensacion de profundidad porque el tamaño de los objetos no depende de la distancia del observador, porque para conseguir este efecto se debe definir una proyeccion perspectiva. Debido a que esta proyeccion define el volumende la vista.
 
Como hemos visto en clase OpenGL proporciona funciones para controlar la traslación, rotación y escalado. Estas tranformaciones se pueden representar como matrices 4x4 ordenadas como vectores columna.
Las  funciones que implementan las transformaciones es:

void glTranslate{fd}(TIPO x, TIPO y, TIPO z);
void glTranslatef(float x, float y, float z);
void glTranslated(double x, dluble y, double z);
void glRotate{fd}(TIPO angulo_en_grados, TIPO x, TIPO y, TIPO z);
void glScale{fd}(TIPO sx, TIPO sy, TIPO sz);

Ejemplo de matriz                                                              Ejemplo de matriz de rotación
De traslación
 
 




4. pila de matrices en opengl lea y resuma el siguiente enlace
las funciones de traslación aplicados en las imágenes provocan la multiplicación de la matriz actual de la imagen por una matriz de traslación creada con los argumentos que se le pasan, por lo que las continuas llamadas a la función display() provocan la creación de constantes multiplicaciones de la matriz actual con el efecto que se observa de incrementar la traslación.

Por ello para solucionar el problema OpenGL llega a dispoder de las pilas de matrices las cuales permiten el almacenamiento y la recuperación de las matrices anteriormente usadas o manejadas. Antes que nada una pila es un almacén con funcionamiento FIFO, 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 disntintas funciones.

En el código que a continuación se muestra, se encuentra declarando dos funciones de matrices las cuales se tratan de glPushMatrix() y glPopMatrix().
La función glPushMatrix() lo que hace es una copia de la matriz superior y la pone encima de la pila, de tal forma que las dos matrices superiores son iguales. 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() provoca la eliminación de la matriz superior, dejando asi en la parte superior de la pila la matriz que estaba en el momento de llamar a la función GlPushMatrix().
void display(void) {
...
// glPushMatrix();
...
glTranslatef(0.0, 0.0, .5);
...
// glPopMatrix();
glutSwapBuffers();
}

Al ejecutar de nuevo la aplicación, primeramente tiene el mismo aspecto que sin comentar las llamadas, pero si obligamos a que se llame varias veces a la función display(). 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.