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.

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

•  Emisión PROPIA

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

6. Fuentes de 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.

Técnicas de Sombreado Clásicas y Avanzadas

Técnicas de sombreado clásicas y avanzadas

Clásicas: Iluminación local

Cálculos de iluminación por vértices: Es necesario que el cálculo del color se lleve a cabo según las luces encendidas por cada vértice y las propiedades de éste.

Posterior relleno de triángulos: Se llevan a cabo varias fases de procesamiento por pixel. Se comprueba cada pixel es visible o no.

Se modifica el color que corresponde, de acuerdo a la textura o transparencia existentes.

En la última fase, se asignan colores a cada pixel de cada triángulo. Dichos colores deben calcularse por el método de Gouraud, interpolando linealmente entre los colores de cada vértice del triángulo que se está visualizando.

Renderizado en tiempo real: La renderización consiste en generar imágenes a partir de un modelo, utilizando algún software de una computadora. Se utiliza en la producción de imágenes en tres dimensiones para video juegos, diseño computacional, efectos especiales del cine y la TV.

El renderizado en tiempo real es en donde todos los movimientos y cambios de escena se calculan en ese mismo instante, debido a que no son predecibles hasta haber tomado una decisión.

Realistas: Iluminación global

Trazado de rayos: Algoritmo para sintetizar imágenes en 3D. Se basa en el algoritmo de determinación de superficies visibles de Arthur Appel denominado Ray Casting, el cual consiste en determinar las superficies que son visibles en la escena que se quiere sintetizar trazando rayos desde la cámara hasta la  escena a través del plano de la imagen.

Este algoritmo, extiende la idea de trazar rayos para determinar las superficies visibles con un proceso de sombreado que tiene en cuenta efectos globales de iluminación.

Radiosidad: Técnica que calcula el intercambio de luz entre superficies difusas, lo cual se consigue subdividiendo el modelo en pequeñas unidades que se denominan parches, los cuales a su vez, se subdividen en unidades más pequeñas, elementos, los cuales serán la base de la distribución de luz final.

Cálculos de iluminación por pixel: Tecnología ofrecida por primera vez por NVIDIA Shading Rasterizer. Este tipo de iluminación libera a los desarrolladores de restricciones y pone efectos sofisticados al alcance. Antes de asignar un color por pixel, se realiza un cálculo de iluminación mediante un ordenador para sombrear los pixeles basándose en alguna luz presente en la escena.

Alto acabado: Se obtiene una intensidad que es aplicada al conjunto de puntos del objeto, el cual representa una superficie plana del objeto modelado  y no de un objeto curvo.

Sombreado Constante o Plano

Un cálculo para todo el polígono:

El sombreado constante aplica un modelo de iluminación sólo una vez y permite determinar un valor de Iλ , para un polígono.

En el sombreado Interpolado, la información de sombreado se interpola linealmente sobre un triángulo, a partir del valor de sus vértices.

Interpolación de Intensidades (Gouraud).

Este método calcula la intensidad de los pixeles a lo largo de la línea de escaneo por interpolación. Elimina la discontinuidad de la intensidad entre los polígonos que se presenta en el método de sombreado con intensidad constante.

Se requiere hacer los siguientes cálculos por cada polígono:

·         Determinar el vector unitario normal de los vértices, el cual es el promedio de las normales de las caras que comparten el vértice.

·         Calcular la intensidad de cada vértice aplicando el modelo de iluminación.

·         Interpolar linealmente las intensidades sobre las aristas del polígono.

·         Interpolar las intensidades de los pixeles entre las aristas.

Interpolación de Normales (Phong).

Este método  interpola las normales para cada punto de la superficie. Consiste en:

·         Determinar el vector unitario de la normal de los vértices, el cual es el promedio de las normales de las caras que comparten el vértice.

·         Interpolar linealmente las normales sobre las aristas del polígono.

·         Interpolar linealmente las normales de los pixeles entre las aristas.

·         Aplicar el modelo de iluminación a lo largo de cada línea de escaneo para calcular las intensidades de cada pixel.

Ray-Tracing

Recortado de caras traseras

Buffer de profundidad: Mantiene valores de distancia para cada pixel. Cada valor representa la distancia existente al pixel desde la posición de la cámara y se escala para quedar dentro del volumen de trabajo actual. Se utiliza para ejecutar la eliminación de caras ocultas y otros efectos especiales.

Buffer de Stencil: Proporciona funciones para restringir el dibujo en pantalla. Puede usarse para cerrar ciertas áreas de la  pantalla. Una de las aplicaciones más interesante es el sombreado.

Buffer de acumulación: proporciona soporte para muchos efectos especiales como difuminado dinámico y profundidad de campo. Soporta antiescalonado a pantalla completa y menos complejo que los otros buffers.

Fuentes de color: Es posible modelar fuentes de luz, para muchas aplicaciones, en  base a los componentes RGB y puede usarse cada uno de los colores fuentes para obtener el componente de color correspondiente.

Luz ambiente: Proviene de una fuente que ha sido disipada por el entorno y no se puede determinar su dirección. Cuando una luz ambiente golpea una superficie, se disipa en todas direcciones.

Spotlights (direccionales): Se caracterizan por un rango de ángulos por los que se emite luz. Puede construirse un spotlight sencillo de una fuente de punto limitando los ángulos de donde la luz fuente se puede ver.

Fuentes de luz distantes: Simula una luz situada a gran distancia del objeto iluminado, Sus parámetros son:

·         Acimut que  es donde se define el ángulo de la dirección de la fuente de luz.

·         Elevación que define el ángulo en grados de la dirección de la fuente de luz por encima del plano.

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 p₀ 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:

 

#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.0f, 0.0f);   
 

  glBegin(GL_POLYGON);       //cara frontal   
  glVertex3f(-1.0f, 0.0f,  1.0f);   
  glVertex3f( 1.0f, 0.0f,  1.0f);   
  glVertex3f( 0.0f,  1.0f,  0.0f);  
 

    glEnd();   


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

glBegin(GL_POLYGON);      //cara trasera   

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

  glShadeModel(GL_SMOOTH);

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

glBegin(GL_POLYGON);       //cara lateral izq   


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

 
  glEnd();   

   glShadeModel(GL_SMOOTH);
 glColor3f(1.0f, 1.0f, 0.0f);   
glBegin(GL_POLYGON);      //cara lateral dcha   

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

 glEnd();

  glShadeModel(GL_SMOOTH);

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

 glBegin(GL_QUADS);       //cara abajo   
 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(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, 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("Piramide Giratoria");   
  init();   
  glutDisplayFunc(display);   
  glutReshapeFunc(reshape);   
  glutIdleFunc(idle);   

  glutMainLoop();   
  return 0;

Proyecto Unidad 2

Proyecto Unidad 2

Proyecto Unidad 2

Código Fuente

#include <glut.h>

float angX=0.0f,angY=0.0f;
int ResX=800,ResY=600;
enum{EJE=2};
float angB=0.0f,angC=0.0f,angDE=0.0f;
float aceX=0.0f,aceY=-0.0001f;
float velX=0.001f,velY=0.0f;
float posX=0.0f,posY=10.0f;

//Colores
GLfloat material [4] = {1.0f, 0.2f, 0.2f, 1.0f };
GLfloat RedMaterial [4] = {1.0, 0.0, 0.0, 1.0 };
GLfloat WhiteMaterial [4] = {1.0, 1.0, 1.0, 1.0 };

void EjesReferencia()
{
glNewList(1,GL_COMPILE);
glBegin (GL_LINES);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, WhiteMaterial );
glVertex3f ( 0.0, 0.0, 0.0);
glVertex3f ( 0.0, 0.0,20.0);
glEnd();
glEndList();
}

void pEJE(){
glNewList(2,GL_COMPILE);
glPushMatrix();
glutSolidSphere(0.5f,100,100);
glPopMatrix();
glEndList();
}


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

//camara
glLoadIdentity( );
glTranslatef(1.0f,0.0f,-10.0f);
glRotatef(angY,1.0f,0.0f,0.0f);
glRotatef(angX,0.0f,1.0f,0.0f);
//EJES DE REFERENCIA
glLineWidth(5);
glCallList(1);
glPushMatrix();
glScalef(1,1,1);
glTranslatef(1.0f,1.0f,1.0f);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, RedMaterial );
glPushMatrix();
glTranslatef(posX,posY,0.0f);
glCallList(EJE);
glPopMatrix();
glutSwapBuffers();
}


void idle(void){
velY+=aceY; posY+=velY;
velX+=aceX; posX+=velX;
if(posY<0.0f){posY=0.0f; velY*=-0.8f;
if(velY<0.01f){velX=0.0f; velY=0.0f;}
}
glutPostRedisplay();
}


int main(int a, char *b[]){
glutInit(&a,b);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(ResX,ResY);
glutInitWindowPosition(100,100);

glutCreateWindow("Proyecto");
glutDisplayFunc(RenderScene);

glutIdleFunc(idle);
glViewport( 0, 0, ResX, ResY );
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
glFrustum(-(float)ResX/ResY, (float)ResX/ResY, -1.0, 1.0, 1, 1000.0);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);

EjesReferencia();
pEJE();
glutMainLoop();
return 0;
}

Traslación

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

}