El Hombre de Jengibre

EJEMPLOS DE USO DE LA GRAFICACION

USOS DE GRAFICACION DE MEDICINA

La primera gran revolución en el terreno de la imagen médica vino de la mano de Wilhelm Conrad von Röntgen (1845-1923) al descubrir los rayos X el 8 de noviembre de 1895. La principal característica de este nuevo descubrimiento era que hacía visible el interior de los objetos, lo que desembocó en un aumento radical de la investigación de las imágenes anatómicas. Aprovechando la radiación de los rayos X (notar que los rayos X son una forma de radiación electromagnética) se consiguieron plasmar, a principios del XX, las primeras imágenes del interior del cuerpo humano, siendo la primera la de la mano de la esposa de Röntgen.

La segunda gran revolución fue el descubrimiento y desarrollo de una técnica basada en los rayos X por la que los físicos Allan MacLeod Cormack (1924) y Godfrey Newbold Hounsfield (1919-2004) recibirían el Premio Nobel de Fisiología o Medicina en 1979: la Tomografía Axial Computerizada (CT o TAC). El éxito de esta técnica viene de que una imagen obtenida en una CT consigue distinguir diferencias mínimas de intensidad, hecho que permitió, por ejemplo, diferenciar, a nivel cerebral, las sustancias gris y blanca.

La tercera gran revolución lleva el nombre de Imagen por Resonancia Magnética (MR o MRI), que permite desde el estudio del cerebro de enfermos de esquizofrenia hasta el de los ligamentos de los deportistas. La MR es un fenómeno físico basado en las propiedades magnéticas que poseen los núcleos atómicos. Fue observado en 1946 por Felix Bloch (1905-1983) y Edward Mills Purcell (1912-1997) y se basa en que ciertos núcleos atómicos

La cuarta gran revolución, la ecografía, está muy ligada a un instrumento bélico, el sonar, desarrollado por científicos franceses durante la Segunda Guerra Mundial. Se trata de una técnica no invasiva basada en la utilización de ultrasonidos (ondas sonoras de alta frecuencia) para estudiar la estructura de los tejidos, diferenciando tejidos sanos de tejidos patológicos. Un aparato llamado transductor emite estos ultrasonidos sobre una zona del cuerpo.

En los últimos años, el auge de la radiología intervencionista y la cirugía mini invasiva ha supuesto la  investigación y el desarrollo de nuevas técnicas y tecnologías capaces de minimizar el impacto de la acción médica en el paciente, las cuales conforman la quinta y última gran revolución en la imagen médica. Algunas de estas técnicas están basadas en, y/o utilizan, alguna de las anteriormente explicadas, pero otras suponen un avance extraordinario no sólo a nivel de la imagen en la medicina, sino en un contexto general a nivel imagen

USOS DE GRAFICACION EN LA EDUCACIÓN

A menudo, se utilizan como instrumentos de ayuda educativa modelos de sistemas físicos, financieros y económicos, los cuales se generan por computadora. Modelos de sistemas físicos, sistemas fisiológicos, tendencias de población o equipo, pueden ayudar a los estudiantes a comprender la operación del sistema. En el caso de algunas aplicaciones de capacitación, se diseñan sistemas especiales, como los simuladores para sesiones de práctica o capacitación de capitanes de barco, pilotos de avión, operadores de equipo pesado y el personal de control de tráfico aéreo. Algunos simuladores no tiene pantallas de video; por ejemplo, un simulador de vuelo que sólo tiene un panel de control como instrumento de vuelo.

Cruces entre lo virtual y lo real

Hacer un mundo dentro de un mundo es inaugurar un conjunto de posibilidades de cruces y simulaciones. En cuanto a lo primero, en la charla se observó que ya es están produciendo vinculaciones entre el mundo real y el virtual en Second Life, que tienen como antecedente sucesos similares que se produjeron en los juegos de rol.

USOS DE GRAFICACION EN LA PUBLICIDAD

La mejor publicidad gráfica siempre ha sido venerada y elevada a la categoría de arte. Propuestas creativas, fotografía, tecnología aplicada a la imagen, etc... Todos son ingredientes de una fórmula donde existe un componente especial. El mensaje.

Sin duda el elemento quizás más importante de toda pieza artística y creativa, y como no, también de los anuncios de la publicidad gráfica donde el objetivo principal se fundamente en conseguir la forma más eficaz de transmitirlo sin necesidad apenas de recurrir a las palabras.

USOS DE GRAFICACION EN EL ENTRETIMIENTO

Es muy común utilizar métodos de gráficas por computadora para producir películas, videos musicales y programas de televisión.

El objetivo de los videojuegos, como medio de ocio, siempre ha sido el de entretener al usuario, desde sus inicios a nuestros días se ha mantenido esta máxima, pero tanto en el contenido como en la apariencia estos han evolucionado a pasos agigantados, avivados entre otras cosas por el rápido desarrollo de diferentes tecnologías. Tanto han evolucionado los videojuegos, que cada vez nos es más difícil relacionar los juegos pioneros con las grandes superproducciones que se lanzan hoy día.

Técnicas de sombreado clásicas 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.

Las insuficiencias de los métodos de iluminación local se han superado en parte por medio de sistemas de iluminación global que permiten tomar en cuenta la interacción entre objetos. Las dos técnicas principales son el trazado de rayos (ray tracing) y la radiosidad (radiosity)

Calculos de iluminación por vértices

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,

glEnable GL_NORMALIZE

o desactivarla con,

glDisable GL_NORMALIZE

el usar GL_NORMALIZE dependerá de nuestra aplicación ya que forzando a que sea OpenGl que las utilice se ralentiza ya que le estamos 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

Es decir, cada vez que queremos definir una normal a un vértice usamos glNormal y el vértice/s que siguen se asocian a esta normal.

La luz de tipo SMOOTH el polígono que definamos tendrá un color definido par cada vértice, asociando las normales a los vértices OpenGL puede hacer los cálculos de los colores a cada uno del vértice y después hace una interpolación de colores con este tipo de luz se acerca bastante al realismo pero a un la podemos mejorar.

Posterior relleno de triangulos

Rellenado de los triángulos (rastering). Para ello se realizan varias fases de procesamiento por Pixel. Comprobar si cada nuevo pixel es visible o no (comprobación de profundidad).

Interpolación lineal del color para el nuevo pixel (método de Gouraud).

Si existe una textura definida o transparencia, efectuar la modificación de color correspondiente.

Se trata de la última fase, en ocasiones la más costosa, del proceso, por lo que es la primera que se suele integrar en el hardware gráfico. En esta etapa 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.

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 los triángulos.

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.

Los métodos principales que existen en la actualidad pueden considerarse como desarrollos, con diferentes variantes, de los dos métodos principales que surgieron en la década de los 1980, ray tracing (introducido por T.Whitted en 1980) y radiosity (hacia 1984 por varios autores). Una base téorica más firme para los algoritmos y métodos de GI (Global Illumination), vino con la publicación, por Kajiya, en 1986 de la rendering equation, que puede encontrarse en un manual especializado

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 específica de un determinado material.

 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. Cada una de estas partes, según su grado de reflexividad, su orientación y su distancia con respecto a las fuentes de luz original, se convertirá, en una segunda vuelta, en un nuevo emisor de energía lumínica, una fuente de luz secundaria que iluminará a su vez a los objetos que le rodean.

Casi todos los modelos de iluminación necesitan conocer la normal de cada superficie para calcular su color.

 El primero, llamado método de Gouraud, efectúa una interpolación a partir de los colores calculados por los vértices del polígono, en los que se conoce la normal. El segundo llamado método de Pong, interpola la normal en el punto en estudio a partir de las normales en los vértices, calculando a continuación el color con la ayuda de esta normal según el modelo de iluminación elegido.

Cálculos de iluminación por pixel

Iluminación por fragmento (por pixel) puede ser elaborada en hardware de gráficos moderno como un proceso de post-rasterización por medio de un programa de shader.

Pixel Shader (PS) como un pequeño programa que procesa fragments (algo así como pixelscon más datos) y que se ejecuta en la GPU. Al crear un PS, se crea una función de procesado de fragmentos que manipula datos de fragmentos.

Frecuentemente necesitan datos del VS, llegando incluso a veces a ser “conducidos” por éste. Por ejemplo, para calcular una iluminación por pixel, el PS necesita la orientación del triángulo, la orientación del vector de luz y en algunos casos la orientación del vector de vista.

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

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.

•    Interpolación de Intensidades (Gouraud)

      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

Calcula normales al polígono

La iluminación cte. no produce buenos resultados en superficies curvas (aprox. por

facetas planas).

Evaluar la ecuación de iluminación en cada punto de una superficie genérica es muy costoso. Posible solución: aproximar mediante facetas planas e interpolar dentro de cada  polígono. Hay que evitar producir una apariencia “faceteada” (bandas de Mach; respuesta del ojo humano).

Sombreado de 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).

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 el lente de la cámara sintética y pasan por el centro de proyección.

Buffer de Profundidad.

El Z-Buffer se basa en que al generar la posición de un punto en la pantalla la computadora reserve una zona de memoria especial, llamada Z-Buffer, información relacionada con la profundidad del punto que ocupa en la escena representada. Cuando el ordenador representa un nuevo punto consulta el Z-Buffer del píxel que corresponde en pantalla. Si el valor que ya existe en el píxel es mayor que el que posee el nuevo punto, el sistema asume que este último es el visible y lo sustituye en la memoria del Z- Buffer.

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.

 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. Este aspecto no será tomado en cuenta en los modelos más sencillos.

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

Fuentes de Color

No solamente las fuentes de luz emiten diferentes cantidades de luz en diferentes frecuencias, pero también sus propiedades direccionales varían con la frecuencia. Por lo tanto, un modelos físicamente correcto puede ser muy complejo. 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.

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.

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

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

Intensidad Completa

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

ELIPSES Y 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.

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.

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

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

Debido a que la elipse y la circunferencia son figuras simétricas el algoritmo genera los vértices del primer cuadrante solamente. Los vértices del segundo cuadrante se crean aplicando simetría axial respecto a los vértices del primer cuadrante, los vértices del tercer cuadrante con respecto a los del segundo y los vértices del cuarto cuadrante con respecto a los del tercero.

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

gluLookAt()

Permite definir de forma específica donde se va a situar la cámara, hacía donde mirará ésta y cuál será el orden de los ejes de coordenadas.

Según sea el valor del vector de vista hacia arriba el objeto que se visualizara tendrá un aspecto diferente.En OpenGL lo tenemos fácil con:

gluLookAt(eyeX, eyeY, eyeZ, atX, atY, atZ, upX, upY, upZ);

Esta es la función que determina dónde y cómo está dispuesta la cámara. Cuidado que la posición de la cámara no tiene nada que ver con el tipo de proyección que hayamos definidoPara ello recordad siempre activar esta matriz antes de llamar a gluLookAt de esta forma:

glMatrixMode(GL_MODELVIEW);

En cuanto a los parámetros que demanda la función son los siguientes:

Coordenadas del "eye". Es literalmente la posición XYZ dónde colocar la cámara dentro del mundo.

Coordenadas del "at". Es el valor XYZ del punto al que queremos que mire la cámara. Un punto del mundo obviamente.

Coordenadas del vector "up". Si, es un vector y no un punto. Con él regularemos la orientación de la cámara. Este ha de ser el vector que "mira hacia arriba" si entendemos que el vector que mira hacia adelante es el que va del "eye" hasta el "at". Variando el "up" variamos la orientación y sino mirad:

Si gluLookAt altera la matriz GL_MODELVIEW y esta es la que guarda el estado de todo nuestro sistema en cuanto a transformaciones (recordad el artículo anterior), mejor controlar la situación con los gl_push y gl_pop que ya conoceis para no desmontarlo todo....y quizás tengais que limpiar la matriz antes de tocar la cámara usando para ello una identidad.....pensad en ello un poco...8)

Carro en 2D

#include <GL/glut.h>

float pos;
int gr;

void reshape(int width, int height){
  glViewport(0, 0, width, height);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
 
    glOrtho(-10, 10, -10, 10, 0.1f, 20);
  glTranslatef(-3.0f, 0.0f, -15.0f);
 
  glMatrixMode(GL_MODELVIEW);
}

void rueda_d(){
  glPushMatrix();
  glColor3f(0,0,0);
  glTranslatef(1.5f,0.0f, 0.0f);
  glRotatef(gr, 0.0f, 0.0f, 1.0f);
  glutSolidSphere(1.0f,20,20);
  glPopMatrix();
}

void rueda_t(){
  glPushMatrix();
  glColor3f(0,0,0);
  glTranslatef(5.5f,0.0f, 3.0f);
  glRotatef(gr, 0.0f, 0.0f, 1.0f);
  glutSolidSphere(1.0f,20,20);
  glPopMatrix();
}


void ventanas(){
  glPushMatrix();
  glColor3f(0,0,0);
  glTranslatef(1.2f,2.0f, 0.01f);

  glBegin(GL_TRIANGLES);
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(0.8f, 0.0f, 0.0f);
      glVertex3f(0.8f, 0.8f, 0.0f);
  glEnd();

  glBegin(GL_QUADS);
      glVertex3f(0.8f, 0.0f, 0.0f);
      glVertex3f(1.7f, 0.0f, 0.0f);
      glVertex3f(1.7f, 0.8f, 0.0f);
      glVertex3f(0.8f, 0.8f, 0.0f);
  glEnd();

  glTranslatef(1.9f,0.0f, 0.0f);

  glBegin(GL_QUADS);
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(0.9f, 0.0f, 0.0f);
      glVertex3f(0.9f, 0.8f, 0.0f);
      glVertex3f(0.0f, 0.8f, 0.0f);
  glEnd();

  glBegin(GL_TRIANGLES);
      glVertex3f(0.9f, 0.0f, 0.0f);
      glVertex3f(1.7f, 0.0f, 0.0f);
      glVertex3f(0.9f, 0.8f, 0.0f);
  glEnd();

  glPopMatrix();
}

void techo(){

  glPushMatrix();

  glTranslatef(1.0f,2.0f, 0.0f);

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

  glBegin(GL_QUADS);
      glVertex3f(1.0f, 0.0f, 0.0f);
      glVertex3f(3.0f, 0.0f, 0.0f);
      glVertex3f(3.0f, 1.0f, 0.0f);
      glVertex3f(1.0f, 1.0f, 0.0f);
  glEnd();

  glBegin(GL_TRIANGLES);
      glVertex3f(3.0f, 0.0f, 0.0f);
      glVertex3f(4.0f, 0.0f, 0.0f);
      glVertex3f(3.0f, 1.0f, 0.0f);
  glEnd();
  glPopMatrix();
}

coche(){
  glColor3f(0,0,1);

  glTranslatef(pos,0.0f, 0.0f);

  glBegin(GL_QUADS);
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(7.0f, 0.0f, 0.0f);
      glVertex3f(7.0f, 2.0f, 0.0f);
      glVertex3f(0.0f, 2.0f, 0.0f);
  glEnd();
}

void display(){
  GLfloat angulo;
  int i;

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glLoadIdentity();
  coche();

  techo();
  ventanas();


  rueda_d();

  rueda_t();

  glutSwapBuffers();
}

void init(){
  glClearColor(1,1,1,0);
  pos=0;
  gr=0;
  glEnable(GL_DEPTH_TEST);
}


void keyboard(unsigned char key, int x, int y){
  switch(key)
    {
    case 'm':
    case 'M':
      pos+=0.1f;
      gr-=180/3.14;
      display();
      break;
 
    case 'n':
    case 'N':
      pos-=0.1f;
      gr+=180/3.14;
      display();
      break;
    }
}

int main(int argc, char **argv){
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutInitWindowPosition(50, 50);
  glutInitWindowSize(600, 600);
  glutCreateWindow("Carro en 2 D");
  init();
  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutKeyboardFunc(keyboard);
  glutMainLoop();
  return 0;
}

Corrida

Programa que se Mueve la Pelota

#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLfloat TrasEsferax= 3.0f;
GLfloat TrasEsferay= 0.0f;
GLfloat TrasEsferaz= -5.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(0.0f, 0.0f, 0.5f);
    glBegin(GL_QUADS);      
    glVertex3f( 4.0f,-4.0f, -4.0f);
    glVertex3f( 4.0f,-4.0f,  4.0f);
    glVertex3f(-4.0f,-4.0f,  4.0f);
    glVertex3f(-4.0f,-4.0f, -4.0f);
    glEnd();
}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

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

   glRotatef(5, 1.0f, 0.0f, 0.0f);
   glRotatef(5, 0.0f, 1.0f, 0.0f);
    drawCube();
    glLoadIdentity();
    glTranslatef(TrasEsferax,TrasEsferay,TrasEsferaz);
   
    glColor3f(0.0f, 1.0f, 0.0f);
    glutWireSphere(0.5f, 8, 8);
    glFlush();
    glutSwapBuffers();

}
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 'j':
    case 'J':
    TrasEsferax-=1.0;
  break;
 case 'l':
    case 'L':
    TrasEsferax+=1.0;
  break;
 case 'i':
    case 'I':
    TrasEsferay+=1.0;
  break;
 case 'k':
    case 'K':
    TrasEsferay-=1.0;
  break;
 case 'u':
    case 'U':
    TrasEsferaz+=0.5;
  break;
 
 case 'y':
    case 'Y':
    TrasEsferaz-=0.5;
  break;

    case 27:  
// exit(0);
      break;
    }
}

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

Corrida

La representación de los objetos en tres dimensiones

La representación de los objetos en tres dimensiones sobre una  superficie plana, de manera que ofrezcan una sensación de volumen se  llama  Perspectiva. Se representan los objetos sobre tres ejes XYZ. En el eje Z,  se representa la altura. En el eje Y, se representa la anchura y en el eje X,  se representa la longitud.

 Los distintos tipos de perspectivas dependen de la inclinación de los  planos Los sistema más utilizados son la isométrica, la caballera y la cónica.  Estudiaremos en este curso las dos primeras.

Perspectiva Isométrica. En ella los ejes quedan separados por un mismo  ángulo (120º). Las medidas siempre se refieren a los tres ejes que tienen su  origen en un único punto.

Perspectiva Caballera. En ella  los ejes X y Z  tienen un ángulo de 90º y el  eje Y con respecto a Z tiene una inclinación de 135º. En es te caso las  medidas  en los ejes X y Z son las reales y las del eje Y tiene un coeficiente  de reducción de 0.5.

DIBUJAR EN PERSPECTIVA

En ambas perspectivas, el sistema más sencillo es llevar las tres  vistas principales sobre los planos formados por los ejes:

     Alzado en el plano XZ.

     Planta en el plano XY.

     Perfil en el plano YZ.

Cada una de las aristas que forman las vistas se prolonga paralelamente  al eje que corresponda:

    Horizontal paralelo al eje de las X.

    Vertical paralelo al eje de las Z.

    Profundidad paralelo al eje de las Y

Transformaciones en OpenGL

En algunos tutoriales anteriores de OpenGL se han mencionado de manera fragmentaria los conceptos de transformaciones:

·         En los “Hola Mundo 3d en OpenGL” y “Hola Complicado Mundo OpenGL-win32” se utilizaron algunas transformaciones de proyección y viewport para ajustar la inicialización de la ventana, pero sin entrar mucho en detalle acerca de su funcionamiento.

Este tutorial explora los diferentes tipos de transformaciones en OpenGL, a saber:

·         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: Que definen y afectan la posición desde la cual se visualizan las escenas tridimensionales.

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

·         void glMatrixMode( enum mode ); Permite seleccionar la matriz sobre la cual se realizaran las operaciones, los posibles valores de mode son TEXTURE, MODELVIEW, COLOR o PROJECTION . Por ahora las más interesantes son MODELVIEW y PROJECTION, las otras se verán en su momento.

·         Void glLoadMatrix{fd} (T m[16]); Recibe una matriz de 4×4 que reemplaza la actual seleccionada. El arreglo es ordenado en forma de una matriz que tiene orden Y, a diferencia de las matrices convencionales que tienen orden X, lo que quiere decir que tiene la forma.

·         void glMultMatrix{fd}( T m[16] ); Multiplica la matriz actual por la matriz m[16] y reemplaza la matriz actual con el resultado de la operación. La operación resultante sería algo así como A’ = A M , donde A es la matriz actual, M es la matriz suministrada y A’ es la nueva matriz que resulta de la operación y que reemplaza a A.

·         void glLoadTransposeMatrix{fd}( T m[16] ); Realiza una función similar a LoadMatrix(), con la diferencia que trabaja sobre una matriz en orden X así.

·         void glMultTransposeMatrix{fd}( T m[16] ); Misma funcionalidad que MultMatrix() , solo que actúa en base al la matriz en orden X, o sea la transpuesta.

·         void glLoadIdentity( void ); Remplaza la matriz actual por la matriz identidad de tamaño 4×4.

Estas operaciones afectan directamente las matrices mencionadas anteriormente, debido a que las operaciones de “alto nivel” (trasladar, rotar, escalar) que existen mas adelante se concatenan, es decir su efecto se acumula sobre matriz actual, existen dos operaciones que permiten guardar la matriz actual en una pila y restaurarla cuando sea necesario, estas son:

·         void glPushMatrix( void ); Coloca una copia de la matriz actual en la parte superior de la pila correspondiente.

·         void glPopMatrix( void ); Saca el elemento superior de la pila, que pasa a reemplazar a la matriz actual.

Estas dos operaciones son muy utilizadas, debido a que permiten realizar transformaciones sobre objetos diferentes, manteniendo algunas de las anteriores sin modificar.

Proyección

Como ya se ha visto en tutoriales anteriores, OpenGL maneja 2 tipos de proyección, en perspectiva y ortográfica, donde la primera corresponde a la visión “realista” de la escena, mientras que la segunda es una “plana” que no deforma las dimensiones de los objetos dependiendo de su distancia a la cámara.

Ortográfica: Para ajustar la proyección ortográfica se utiliza el siguiente grupo de funciones:

glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);

gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);

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)

Transformaciones ModelView

Una tarea muy común en la creación de gráficos 2d, 3d y videojuegos es la de mover objetos par crear cierta animación. La primera idea que se nos viene a la cabeza en el caso de OpeGL es que todo modelo está formado por primitivas, toda primitiva por puntos y finalmente todo punto por una tripleta de coordenadas XYZ, así que si se cambian las coordenadas todo de ahí hacia arriba se mueve.

void glRotate[fd](GLfloat angle, GLfloat x, GLfloat y, GLfloat z);

Hay que tener en cuenta las siguientes características a la hora de utilizar estas funciones:

·         Estas tres operaciones afectan la matriz actual seleccionada, bien sea MODELVIEW o PROJECTION, generalmente para propósitos de rotar objetos dentro de la escena se utiliza la matriz MODELVIEW.

·         El eje coordenado de referencia para las operaciones tanto en MODELVIEW como en PROJECTION se denomina “eye coordinates”, que traduce coordenadas de “ojo” o mejor “vista”. Este es un sistema inamovible y en ausencia de cualquier transformación, la “cámara” está situada en (0,0,0) apuntando hacia la dirección Z negativa, con el vector “arriba” en el sentido Y positivo.

·         Cada operación que afecta la matriz MODELVIEW crea otro sistema coordenado para los objetos que se dibujen después de realizada la trasformación, dicho sistema difiere del “básico”, es decir de las llamadas coordenadas de vista (eye coordinates) dependiendo de todo el conjunto de transformaciones realizadas desde el momento en que la matriz MODELVIEW dejo de ser la identidad.

·         Una consecuencia de lo anterior es que las operaciones no son conmutativas, es decir que un llamado de glRotatef(), seguido de uno de glTranslatef() produce un efecto diferente a llamar las operaciones en orden inverso. Esto se ve mejor ilustrado en el gráfico:

·         Es importante aprender a utilizar correctamente glPushMatrix(), glPopMatrix() y otras operaciones que permitan salvar y restaurar estados de matriz, debido a que permiten realizar translaciones y rotaciones especificas para un cierto objeto, sin alterar los otros.

Hardware

En realidad, el API de ogl está pensado para trabajar bajo el respaldo de un hardware capaz de realizar las operaciones necesarias para el renderizado, pero si no se dispone de ese hardware, estas operaciones se calcularan por medio de un software contra la CPU del sistema. Así que los requerimientos hardware son escasos, aunque cuanto mayor sea las capacidades de la maquina, mayor será el rendimiento de las aplicaciones ogl.

Windows

En principio, cualquier versión de windows viene con las librerías necesarias para ejecutar cualquier aplicación que utilice OpenGL. Para el desarrollo de las mismas, el Microsoft Visual Studio, y en particular Visual C++ trae también todo lo necesario. Puedes consegir, además, la última versión de la GLUT en la web de Nate Robins.

Linux

Para visualizar aplicaciones OpenGL en XFree86 necesitarás instalar un paquete para el soporte de las librerías Mesa (que es el equivalente en software libre de OpenGL) y de las utilidades GLU y GLUT. Para realizar desarrollo necesitarás, a mayores, los paquetes equivalentes en modo dev.

En el caso de la distribución Ubuntu los paquetes necesarios para desarrollo y visualización son los siguientes:

 - Freeglut3-dev

 - libgl1-mesa-dev

 - libglu1-mesa-dev

 - libglut3.dev

Coordenadas oculares

Las coordenadas oculares se sitúan en el punto de vista del observador, sin importar las transformaciones que tengan lugar. Por tanto, estas coordenadas representan un sistema virtual de coordenadas fijo usado como marco de referencia común.

Transformaciones

Las transformaciones son las que hacen posible la proyección de coordenadas 3D sobre superficies 2D. También son las encargadas de mover, rotar y escalar objetos.

El modelador

En esta sección se recogen las transformaciones del observador y del modelado puesto que, como se verá en el apartado, constituyen, al fin y al cabo, la misma transformación.

Transformaciones del observador

La transformación del observador es la primera que se aplica a la escena, y se usa para determinar el punto más ventajoso de la escena. Por defecto, el punto de vista está en el origen (0,0,0) mirando en dirección negativa del eje z. La transformación del observador permite colocar y apuntar la cámara donde y hacia donde se quiera.

Transformaciones del modelo

Estas transformaciones se usan para situar, rotar y escalar los objetos de la escena. La apariencia final de los objetos depende en gran medida del orden con el que se hayan aplicado las transformaciones.

Transformaciones de la proyección

 La transformación de proyección se aplica a la orientación final del modelador. Esta proyección define el volumen de visualización y establece los planos de trabajo

 Los dos tipos de proyección más utilizados son la ortográfica y la perspectiva, que veremos más adelante.

Transformaciones de la vista

 En el momento en que se ha terminado todo el proceso de transformaciones, solo queda un último paso: proyectar lo que hemos dibujado en 3D al 2D de la pantalla, en la ventana en la que estamos trabajando.

Matrices

 Las matemáticas que hay tras estas transformaciones se simplifican gracias a las matrices. Cada una de las transformaciones de las que se acaba de hablar puede conseguirse multiplicando una matriz que contenga los vértices por una matriz que describa la transformación.

El canal de transformaciones

Para poder llevar a cabo todas las transformaciones de las que se acaba de hablar, deben modificarse dos matrices: la matriz del Modelador y la matriz de Proyección.

La matriz del modelador

La matriz del modelador es una matriz 4x4 que representa el sistema de coordenadas transformado que se está usando para colocar y orientar los objetos.

La matriz de proyección

La matriz de proyección especifica el tamaño y la forma del volumen de visualización. El volumen de visualización es aquel cuyo contenido es el que se representa en pantalla.

Proyecciones ortográficas

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

Proyecciones perspectivas

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