GALLETA GENGIBRE

Vista # 1

VISTA FINAL

 

UNIDAD V

5.1 Procesamiento de imagenes
Tiene como objetivo mejorar el aspecto de las imagenes y hacer mas evidentes en ellas ciertos detalles que se desean hacer notar. La imagen puede haber sido generada de muchas maneras como fotograficamente o electronicamente por medio de television. El procesamiento de las imagenes se puede hacer por medio de metodos opticos, o bien por medio de metodos digitales, en una computadora.

PROCESO DE FILTRADO
Los principales objetivos son:

- Suavizar la imagen. reducir la cantidad de variaciones de intensidad entre pixeles vecinos.
- Eliminar ruido. Eliminar aquellos pixeles cuyo nivel de intensidad es muy diferente al de sus vecinos y cuyo origen puede estar tanto en el proceso de adquisicion de la imagen como en el de transmision.
- Realzar bordes. Destacar los bordes se localizan en una imagen.
- Detectar bordes. Detectar los pixeles donde se produce un cambio brusco en la funcion intensidad.


5.2 VISION POR COMPUTADORA
La vision por computadora es una rama de la inteligencia artificial que tiene por objetivo modelar matematicamente los procesos de percepcion visual en los seres vivos y generar programas que permitan simular estas capacidades visuales por computadora.

El proceso de vision por computadora puede subdividirse en sus areas principales:

- Sensado. Es el proceso que nos lleva a la obtencion de una imagen visual
- Preprocesamiento. Trata de las tecnicas de reduccion de ruido y enriquecimiento de detalles en la imagen
- Segmentacion. Es el proceso que particiona una imagen en objetos de interes
- Descripcion. Trata con el computo de caracteristicas utiles para diferenciar un tipo de objeto de otro.
- Reconocimiento. Es el proceso que identifica esos objetos
- Interpretacion. Asigna un significado a un conjunto de objetos reconocidos.

5.3 ANIMACION POR COMPUTADORA
La animacion es la simulacion de un movimiento, creada por la muestra de una serie de imagenes o cuadros. Un ejemplo sencillo de esto son las caricaturas, que pertenecen a la animacion tradicional. Hace algunos anos se debia de dibujar cada cuadro y se unian para formar una imagen animada. Ahora, el uso de la computadora permite crear escenas mucho mas reales.

La animacion por computadora se puede definir como un formato de presentacion de informacion digital en movimiento a traves de una secuencia de imagenes o cuadros creadas o generadas por la computadora se utiliza principalmente en videojuegos y peliculas.

Tecnicas de animacion:

- Animacion en acetatos. Los acetatos de animacion se colocan en capas, una encima de la otra, para producir un solo cuadro de animacion. Se utiliza un acetato separado para la capa del fondo y otro para cada objeto que se mueve independientemente sobre el fondo.

- Animacion basada en cuadros. Es el tipo mas simple de animacion. Quiza de nino tuvieron uno de esos libros que contenian una serie de dibujos al hojear rapidamente el libro, los dibujos de las paginas sucesivas aparentaban movimiento.

- Animacion en Sprite. Esta animacion es tambien llamada animacion basada en repartos cada un sprite puede ser un objeto, es sobrepuesto y animado sobre un fondo estatico. Esta animacion es muy comun en videojuegos.

ACTIVIDAD
Graficacion en medicina.
Uno de los precursores en el estudio cientifico y detallado del terreno de la medicina a traves de la imagen fue Andreas Vesalio. Pero vesalio y sus sucesores dibujaban a mano todos sus modelos, algo que desde una perspectiva moderna, es poco eficiente. No podrian haberse imaginado el desarrollo tan espectacular que iba a sufrir su campo tres siglos mas tarde.

La segunda gran revolucion fue el descubrimiento y desarrollo de los rayos X. El exito de esta tecnica viene de que una imagen obtenida en una CT consigue distinguir diferencias minimas de intensidad, hecho que permitio, por ejemplo, diferenciar a nivel cerebral, las sustancias gris y blanca.

La tercera gran revolucion fue La Resonancia Magnetica que permite desde el estudio del cerebro de enfermos de esquizofrenia hasta el de los ligamentos de los deportistas. La MR es un fenomeno fisico basado en las propiedades magneticas que poseen los nucleos atomicos.

La cuarta gran revolucion fue la ecografia, esta muy ligada a un instrumento belico, el sonar, desarrollado por cientificos en la SGM. Se trata de una tecnica no invasiva basada en la utilizacion de ultrasonidos para estudiar la estructura de los tejidos, diferenciando tejidos sanos de tejidos patologicos.

 GRAFICACION EN EDUCACION
 Se utilizan instrumentos a menudo como ayuda educativa, modelos de sistemas fisicos, financieros y economicos, los cuales se generan por computadora. Modelos de sistemas fisicos, sistemas fisiologicos, tendencias de poblacion o equipo, pueden ayudar a los estudiantes a comprender la operacion del sistema. En el caso de algunas aplicaciones de capacitacion, se disenan sistemas especiales, como los simuladores para sesiones de practica o capacitacion de capitanes de barco, pilotos de avion, operadores de equipo pesado y el personal de control de trafico aereo. Algunos simuladores no tiene pantallas de video, por ejemplo simulador de vuelo. No obstante, la mayor parte de los simuladores cuenta con pantallas graficas para la operacion visual.

GRAFICACION EN PUBLICIDAD

La mejor publicidad grafica siempre ha sido venerada y elevada a la categoria de arte. Propuestas creativas, fotografia, tecnologia aplicada a la imagen, etc. todos son ingredientes de una formula donde existe un componente especial. El mensaje.

Sin duda el elemento quizas mas importantes en toda pieza artistica y creativa  y como no tambien de anuncios de la publicidad grafica donde el objetivo principal se fundamente en conseguir la forma mas eficaz de transmitirlo sin necesidad apenas de recurrir a las palabras.



GRAFICACION EN ENTRETENIMIENTO
Es muy comun utilizar metodos de graficos por computadora para producir peliculas, videos musicales y programas de television. En ocasiones, se despliegan solo imagenes graficas y otras veces, se combinan los objetos con los actores y escenas en vivo. Por ejemplo en una escena grafica para la pelicula Start Treck, se dibujan en forma de armazon el planeta y la nave espacial y se sombrean con metodos de presentacion para producir superficies solidas. Al igual que pueden aparecer personas en forma de armazon combinadas con actores y una escena en vivo. Los videos musicales aprovechan las graficas de muchas maneras, se pueden combinar objetos graficos con accion en vivo, o se pueden utilizar tecnicas de procesamiento de imagenes para producir una transformacion de una persona o un objeto en otro.

CRUCIGRAMA

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

La luz puede dejar una superficie mediante dos procesos fundamentales:

•          2. 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

Se describe una fuente mediante una función de 5. INTENSIDAD o 8. LUMINANCIA de tres componentes.

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

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

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

Luces 11. 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.

1. Como activar las fuentes de luz en OpenGL

Para habilitar el modo de iluminacion se realiza con la funcion glEnable(GL_LIGHTING), cuando renderizamos en este modo la instruccion glColor no tienen ninguna influencia ya que el color resultante de cada vertice es calculado a aprtir de los materiales del vertice y las luces que haya encendidas.

Cada luz se puede configurar estableciendo los siguientes parametros con la funcion glLight(if)v:

GL_AMBIENT (0.0, 0.0, 0.0, 1.0) = Intensidad ambiente de la luz
GL_DIFFUSE (1.0, 1.0, 1.0, 1.0) GL_LIGHT0 (0.0, 0.0, 0.0, 1.0) GL_LIGHT1-GL_LIGHT7 = intensidad difusa de la luz
GL_SPECULAR (1.0, 1.0, 1.0, 1.0) GL_LIGHT0 (0.0, 0.0, 0.0, 1.0) GL_LIGHT1-GL_LIGHT7 = intensidad especular de la luz
GL_POSITION (0.0, 0.0, 0.0, 1.0) = (x, y, z, w) Posicion de la luz
GL_SPOT_DIRECTION (0.0, 0.0, -1.0) = (x, y,z) direccion de la luz
GL_SPOT_EXPONENT (0.0) = exponente del foco
GL_SPOT_CUTOFF (180.0) = angulo de abertura del foco
GL_CONSTANT_ATTENUATION (1.0) = factor de atenuacion constante
GL_LINEAR_ATTENUATION (0.0) = factor de atenuacion lineal
GL_QUADRATIC_ATTENUATION (0.0) = factor de atenuacion cuadratico

2. Como calcular la normal para cada vertice 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.

3 Ejemplos de Codigo OpenGL manejando la iluminacion

GUIA EXAMEN UNIDAD 3

Llene los espacios en blanco completando los conceptos con las siguientes palabras

2. Curvas de Bezier. Se definen por una serie de puntos de control
3. Curvas de Bezier: Lineales (GRADO 1) Solo dos puntos de control (P0 y P1)
4. Curvas de Bezier: Cuadraticas (GRADO 2) Tres puntos de control (P0, P1 y P2)
5. Curvas de Bezier: Cubicas (Grado 3) Cuatro puntos de control (P0, P1, P2 y P3).


Dibuje un ejemplo de cada tipo de curvas de Bezier mencionadas en las preguntas anteriores. 25 pts.

a) Curvas de Bezier

b) Curvas de Bezier: Lineales (Grado 1)

c) Curvas de Bezier: Cuadraticas (Grado 2)

d) Curvas de Bezier: Cubicas (Grado 3)

7. Utilizando el siguiente dibujo, genere los vertices y codigo necesario para dibujarlo sin relleno y tomando en cuenta el Vo y la medida de cada lado.

 CARA A (enfrente)
glBegin(GL_POLYGON);
        glVertex3f(0.0, 0.0, 2.0);
        glVertex3f(-2.0, 0.0, 2.0);
        glVertex3f(2.0, 2.0, 2.0);
        glVertex3f(0.0, 2.0, 2.0);
glEnd();

CARA B (arriba)
glBegin(GL_POLYGON);        glVertex3f(0.0, 2.0, 2.0);
        glVertex3f(2.0, 2.0, 2.0);
        glVertex3f(2.0, 4.0, 0.0);
        glVertex3f(4.0, 4.0, 0.0);
glEnd();

CARA C (atras)
glBegin(GL_POLYGON);
        glVertex3f(0.0, 2.0, 2.0);
        glVertex3f(4.0, 0.0, 0.0);
        glVertex3f(4.0, 4.0, 0.0);
        glVertex3f(0.0, 4.0, 0.0);
glEnd();

CARA D (abajo)
glBegin(GL_POLYGON);
        glVertex3f(0.0, 0.0, 0.0);
        glVertex3f(0.0, 0.0, 2.0);
        glVertex3f(-2.0, 0.0, 2.0);
        glVertex3f(4.0, 0.0, 0.0);
glEnd();

CARA E (lateral izquierda)
glBegin(GL_POLYGON);
        glVertex3f(0.0, 0.0, 0.0);
        glVertex3f(0.0, 0.0, 2.0);
        glVertex3f(0.0, 2.0, 2.0);
        glVertex3f(0.0, 4.0, 0.0);
glEnd();

CARA F (lateral derecha)
glBegin(GL_POLYGON);
        glVertex3f(2.0, 2.0, 2.0);
        glVertex3f(-2.0, 0.0, 2.0);
        glVertex3f(4.0, 0.0, 0.0);
        glVertex3f(4.0, 4.0, 0.0);
glEnd();

8. Que linea debe cambiar para dibujarlo con relleno?
glShadeMode(x, y, z)

9. Que es el doble bufereo y para que nos sirve?
Doble-Buffer es una tecnica para reducir el parpadeo producido al dibujar en la pantalla. Esta tecnica es muy util para cuando tenemos varios segmentos de imagen complejos por dibujar, por ejemplo el movimiento de un objeto complejo sobre una ventana.

10. Que es el z-buffer y para que sirve, como se activa en opengl?
el z-buffering es la parte de l amemoria de un adaptador de video encargada de gestionar las coordenadas de profundidad de las imagenes en los graficos en 3D, normalmente calculados por hardware y algunas veces por software. Es una de las soluciones al problema de visibilidad, que es el problema de decidir que elementos de una escena renderizada son visibles y cuales ocultos

OPENGL:
glDepthFunc (GL_LEQUAL);
glEnable (GL_DEPTH_TEST);
glClearDepth(1.0);

11. Que pasa si no se activa el z-buffer?
Como es un arreglo que guarda profundidad (eje z), si un pixel va a ser dibujado, ve si su coordendaa Z es menor que la coordenada en el Z-Buffer para ese pixel en pantalla si no esta activado no oculta el objeto, lo muestro uno encima de otro.

12. Describa el funcionamiento de Pipeline de graficacion (diagrama)

 
 

 

PROYECTO UNIDAD 3 PIRAMIDE

CODIGO:

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


 void drawCube(void){   

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

  glShadeModel(GL_SMOOTH);
 glColor3f(0.4f, 1.0f, 0.0f);

glBegin(GL_POLYGON);    
  glVertex3f(-1.0f, 0.0f,  -1.0f);   
  glVertex3f( 1.0f, 0.0f,  -1.0f);   
  glVertex3f( 0.0f,  2.0f,  0.0f);
    glEnd();   

  glShadeModel(GL_SMOOTH);

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


glBegin(GL_POLYGON);   

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


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

 


  glShadeModel(GL_SMOOTH);

 glColor3f(1.0f, 0.3f, 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); 
 
  drawCube();    
 
  glLoadIdentity();    
  glTranslatef(0.0f, 0.0f, -5.0f);   
  glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f);   
  glTranslatef(3.0f, 0.0f, 0.0f);    
  glColor3f(1.0f, 1.0f, 1.0f);   
  
  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();
}

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

  glutMainLoop();   
  return 0;

 }

TECNICAS DE SOMBREADO CLASICAS Y AVANZADAS

Clasicas: Iluminacion Local.

Son las luces que no son extensas, como las reales, sino puntuales. Se relacionan con los objetos aislados sin tener en cuenta la interaccion entre ellos.

Las insuficiencias de los metodos de iluminacion local se han superado en pare por medio de sistemas de iluminacion global que permiten tomar en cuenta la interaccion entre objetos. Las dos tecnicas principales son el trazado de rayos y la radiosidad.

-          Calculo de iluminacion por vertices. Se necesita calcular el vector normal asociado. Cuando se tiene la normal calculada se tiene que normalizar, dividir ese vector por su propio modulo para que sea unitario

OpenGL: glEnable GL_NORMALIZE

Para definir normales en openGL se utiliza la opcion glNormal3f(x, y, z).

-          Posterior relleno de triangulos. Se realizan varias fases de procesamiento por pixel. Comprobar si cada nuevo pixel es visible o no. Interpolacion lineal del color para el nuevo pixel.

Si existe una textura definida o transparencia, efectuar la modificacion de color correspondiente. Se trata de la ultima fase, en ocasiones la mas costosa, del proceso, por lo que es la primera que suele integrar en el hardware grafico.

-          Renderizado en tiempo real. Los ojetos deben ser descompuestos en poligonos. Estos poligonos seran descompuestos a su vez en triangulos. Cada triangulo sera proyectado sobre la ventana y rellenado con los colores adecuados para reflejar los efector de la iluminacion, texturas, etc. Una va vez generado los triangulos, comienza una segunda fase de calculos realizados para cada pixel cubierto por los triangulos.

REALISTAS: ILUMINACION GLOBAL

Son sencillos y rapidos pero proporcionan imágenes muy simples, que no representen el modo en que la luz ilumina los objetos y los espacios. Los metodos principales que existen son el ray tracing y el radiosity. 

-          Trazado de rayos. Computa la interaccion de la luz desde un punto de vista determinado y es adecuado para superficies reflectantes. Puede utilizarse como propiedad especifica de un determinado material.

-          Radiosidad. Esta basado en principios generales. En el estado inicial la escena consta de dos tipos de objetos: objetos que emiten luz y objetos que reciben luz. A partir de ahí se computa la luz que recibe cada objeto o, en una aproximacion mas exacta, cada parte de un objeto, según una subdivision cuya densidad puede precisarse en sucesivas aproximaciones.

-          Calculos de iluminacion por pixel. Puede ser elaborada en hardware de graficos como un proceso de post-rasterizacion por medio de un programa de shader. Frecuentemente necesitan datos del VS, llegando incluso a veces a ser conducidos por este.

-          Alto acabado. Un calculo para todo el poligono. Se obtiene una intensidad que se aplica a un conjunto de puntos de un objeto. Se acelera el proceso de sintesis. El poligono representa una superficie plana real del objeto que se modela y no es una aproximacion de un objeto curvo.

SOMBREADO CONSTANTE O PLANO.

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

-          Aceleramos el proceso de sintesis

-          Correcto si se verifica

-          Fuente de luz en el infinito

-          Observador en el infinito.

CALCULO

Para cada cara visible, se elige un punto de la cara P; por ejemplo:

1.       Un vertice

2.       Una combinacion convexa de los vertices de la cara P1

3.       Se calculan los valores unitarios necesarios en P

4.       A todos los pixeles correspondientes a esta cara se les asigna este color/iluminacion

5.       No hay gradiente de iluminacion en una cara

6.       No hay problema en obtener P en mundo real.

SOMBREADO SUAVE DE GOURAUD

El calculo de la iluminacion se hace en mundo real. La interpolacion bilineal se hace en coordenadas de pantalla (a partir de iluminacion de vertices). Hay que normalizar (hacer UNITARIOS) los vectores normales a los vertices. No se aplica el filtro a los vertices.

Para todos los vertices de las caras visibles:

1.       Se calcula la normal (UNITARIA) asociada al vertice como promedio de las normales (UNITARIAS) de las caras que contienen el vertice (incluidas las caras ocultas)

2.       Se calcula la iluminacion (color) asociada al vertice, usando esta normal

Iluminacion asociada a pixel/punto de la cara como interpolacion bilineal de las iluminaciones de los vertices:

1.       Cara ABC

2.       Interseccion de scan con AB yAC: P1 y P2

3.       Punto/pixel P, entre P1 y P2

4.       Iluminaciones en P1, P2 como interpolacion de iluminaciones en A, B, C

5.       Iluminacion en P como interpolacion de iluminaciones en P1, P2

6.       Calculo incremental de iluminacion en P:

1.       Siguiente punto del Scan, Q, Tiene Xq = Xp + 1

7.       Tambien es posible calculo incremental de I1, I2

SOMBREADO SUAVE DE PHONG

CALCULO

Mas que costoso que Gouraud, pero resultados mas naturales. Hay que normalizar normales interpoladas (en cada punto/pixel)

1.       Calculo de la normal Unitaria asociada a cada vertice

2.       Interpolacion bilineal de normales para encontrar normal a punto/pixel de la cara.

3.       Se calcula iluminacion en P a partir de este vector normal

4.       Obtencion de varios vertices

1.       Obtener el punto P en mundo real correspondiente a pixel bajo estudio es dificil

2.       Se puede aproximar y usar L y V constantes at oda la cara

3.       Se pueden interpolar a partir de los valores.

Ray Tracing. Es un algoritmo para sintesis de imágenes tridimensionales. Propuesto por Turner Whitted esta basado en el algoritmo de determinacion de superficies visibles.

Buffer de Profundidad. Se utiliza para evitar que los objetos que esten detrás se dibujen delante de los que los tapan. Por cada pixel dibujado en la pantalla, se almacena su coordenada Z. Si posteriormente se va a dibujar un punto en esa misma posicion, se comprueba si el que esta ya dibujado va delante o atrás.

Buffer de Stencil. Utilizada para guardar el patron correspondiente a la sombra que un objeto proyectara sobre otro en funcion de la posicion de la fuente de luz. Este buffer tambien suele ser empleado por la GPU para evaluar la complejidad de una escena.

Fuente de Color. Un modelo fisicamente correcto puede ser muy complejo. Para la mayoria de las aplicaciones, se puede modelar fuentes de luz en base a 3 componentes primarios, RGB, y puede usar cada uno de los 3 colores fuentes para obtener el componente de color correspondiente que un observador humano veria.

Luz Ambiente. O tambien se puede llamar iluminacion uniforme, se logra mediante fuentes grandes con difusores cuyo proposito es esparcir la luz en todas las direcciones. 

Spotlights (direccionales). Se caracterizan por un rango delgado de angulos por los cuales se emite luz. Se puede construir spotlight sencillo de una fuente de punto limitando los angulos de donde la luz de la fuente se puede ver.

Fuentes de luz distantes. Requieren la direccion 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 computacion que es una parte significativa del calculo del sombreado.

Intensidad Completa. La intensidad completa es exclusivamente por efectos de iluminacion.

PROGRAMA DE ILUMINACION

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void init(void)
{
   GLfloat mat_specular[] = { 1.0, 0.0, 0.0, 1.0 };
   GLfloat mat_shininess[] = { 50.0 };
   GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
   GLfloat light_position_2[] = { -1.0, 1.0, 1.0, 0.0 };
   GLfloat light_ambient[] = { 0.5, 0.1, 0.1, 1.0 };
   GLfloat light_diffuse[] = { 0.0, 1.0, 0.0, 1.0 };
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_FLAT);

   glLightfv(GL_LIGHT0, GL_POSITION, light_position);

   glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
   glLightfv(GL_LIGHT1, GL_POSITION, light_position_2);

   glLightfv(GL_LIGHT2, GL_AMBIENT, light_ambient);

   glEnable(GL_LIGHTING);

   glEnable(GL_LIGHT0);
   glEnable(GL_LIGHT1);
   glEnable(GL_LIGHT2);

   glEnable(GL_DEPTH_TEST);
}

void display(void)
{
   GLfloat no_mat[] = { 0.0, 0.0, 0.0, 1.0 };
   GLfloat mat_ambient[] = { 0.7, 0.7, 0.7, 1.0 };
   GLfloat mat_ambient_color[] = { 0.8, 0.8, 0.2, 1.0 };
   GLfloat mat_diffuse[] = { 0.1, 0.5, 0.8, 1.0 };
   GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
   GLfloat no_shininess[] = { 0.0 };
   GLfloat low_shininess[] = { 5.0 };
   GLfloat high_shininess[] = { 100.0 };
   GLfloat mat_emission[] = {0.3, 0.2, 0.2, 0.0};
   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);

   glutSolidSphere(1.0, 64, 32);

   glFlush ();
}

void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity();
   if (w <= h)
      glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w,
         1.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
   else
      glOrtho (-1.5*(GLfloat)w/(GLfloat)h,
         1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0, 10.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (500, 500);
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display);
   glutReshapeFunc(reshape);
   glutMainLoop();
   return 0;
}

RAUL ERASMO LERMA LERMA


Programa Cubo - Esfera

TRANSFORMACIONES GEOMETRICAS

OpenGL

a) 

 TRASLACION

  

#include <GL/glut.h>
void display(void)

{

glClear (GL_COLOR_BUFFER_BIT);

    glTranslatef(-2.0, -2.0, 0.0);

    glColor3f(1.0, 0.6, 0.2);

    glBegin(GL_POLYGON);

        glVertex2f (2.0, 2.0);

        glVertex2f (7.0, 2.0);

        glVertex2f (7.0, 7.0);

        glVertex2f (-2.0, 7.0);   

    glEnd();

    glFlush ();

}

void init (void)

{

    glClearColor (0.0, 0.0, 0.0, 0.0);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrtho(-3.0, 6.0, -2.0, 6.0, -5.0, 5.0);

}

int main(int argc, char** argv)

{

    glutInit(&argc, argv);

    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

    glutInitWindowSize (250, 250);

    glutInitWindowPosition (100, 100);

    glutCreateWindow ("hello");

    init ();

    glutDisplayFunc(display);

    glutMainLoop();

    return 0;

 }

ESCALACION

 

#include <GL/glut.h>

void display(void)

{

glClear (GL_COLOR_BUFFER_BIT);

                glScalef(0.5, 0.5, 0.0)

    glColor3f (1.0, 0.8, 0.6);

    glBegin(GL_POLYGON);

        glVertex2f (2.0, 2.0);

        glVertex2f (7.0, 2.0);

        glVertex2f (7.0, 7.0);

        glVertex2f (2.0, 7.0);   

    glEnd();

    glFlush ();

}

void init (void)

{

    glClearColor (0.0, 0.0, 0.0, 0.0);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrtho(-3.0, 6.0, -2.0, 6.0, -5.0, 5.0);

}

int main(int argc, char** argv)

{

    glutInit(&argc, argv);

    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

    glutInitWindowSize (250, 250);

    glutInitWindowPosition (100, 100);

    glutCreateWindow ("hello");

    init ();

    glutDisplayFunc(display);

    glutMainLoop();

    return 0;

 }

ROTACION

#include <GL/glut.h>

void display(void)

{

glClear (GL_COLOR_BUFFER_BIT);

                glRotatef(45.0, 0.0, 0.0,1.0)

    glColor3f (0.2, 0.8, 0.6);

    glBegin(GL_POLYGON);

        glVertex2f (2.0, 2.0);

        glVertex2f (7.0, 2.0);

        glVertex2f (7.0, 7.0);

        glVertex2f (2.0, 7.0);   

    glEnd();

    glFlush ();

}

void init (void)

{

    glClearColor (0.0, 0.0, 0.0, 0.0);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrtho(-4.0, 4.0, 1.0, 6.0, -3.0, 8.0);

}

int main(int argc, char** argv)

{

    glutInit(&argc, argv);

    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

    glutInitWindowSize (250, 250);

    glutInitWindowPosition (100, 100);

    glutCreateWindow ("hello");

    init ();

    glutDisplayFunc(display);

    glutMainLoop();

    return 0;

}

 

 b)

TRASLACION

 

#include <GL/glut.h>

void display(void)

{

glClear (GL_COLOR_BUFFER_BIT);

    glTranslatef(-2.0, -2.0, 0.0);

    glColor3f(1.0, 0.6, 0.2);

    glBegin(GL_POLYGON);

        glVertex2f (2.0, 2.0);

        glVertex2f (7.0, 2.0);

        glVertex2f (7.0, 7.0);

        glVertex2f (-2.0, 7.0);   

    glEnd();

    glFlush ();

}

void init (void)

{

    glClearColor (0.0, 0.0, 0.0, 0.0);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrtho(-3.0, 6.0, -2.0, 6.0, -5.0, 5.0);

}

int main(int argc, char** argv)

{

    glutInit(&argc, argv);

    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

    glutInitWindowSize (250, 250);

    glutInitWindowPosition (100, 100);

    glutCreateWindow ("hello");

    init ();

    glutDisplayFunc(display);

    glutMainLoop();

    return 0;

 }

ESCALACION

 

#include <GL/glut.h>

void display(void)

{

glClear (GL_COLOR_BUFFER_BIT);

                glScalef(0.5, 0.5, 0.0)

    glColor3f (0.2, 0.8, 0.6);

    glBegin(GL_POLYGON);

        glVertex2f (0.0, 0.0);

        glVertex2f (5.0, 0.0);

        glVertex2f (5.0, 5.0);

        glVertex2f (0.0, 5.0);   

    glEnd();

    glFlush ();

}

void init (void)

{

    glClearColor (0.0, 0.0, 0.0, 0.0);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrtho(-3.0, 6.0, -2.0, 6.0, -5.0, 5.0);

}

int main(int argc, char** argv)

{

    glutInit(&argc, argv);

    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

    glutInitWindowSize (250, 250);

    glutInitWindowPosition (100, 100);

    glutCreateWindow ("hello");

    init ();

    glutDisplayFunc(display);

    glutMainLoop();

    return 0;

 }

ROTACION

#include <GL/glut.h>

void display(void)

{

glClear (GL_COLOR_BUFFER_BIT);

                glRotatef(45.0, 0.0, 0.0,1.0)

    glColor3f (0.2, 0.2, 0.6);

    glBegin(GL_POLYGON);

        glVertex2f (0.0, 0.0);

        glVertex2f (2.5, 0.0);

        glVertex2f (2.5, 2.5);

        glVertex2f (0.0, 2.5);   

    glEnd();

    glFlush ();

}

void init (void)

{

    glClearColor (0.0, 0.0, 0.0, 0.0);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrtho(-4.0, 4.0, 1.0, 6.0, -3.0, 8.0);

}

int main(int argc, char** argv)

{

    glutInit(&argc, argv);

    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

    glutInitWindowSize (250, 250);

    glutInitWindowPosition (100, 100);

    glutCreateWindow ("hello");

    init ();

    glutDisplayFunc(display);

    glutMainLoop();

    return 0;

}