Resumen Material de examen.

Procesamiento de imagenes:

El procesamiento digital de imagenes se distinguen dos niveles principales de manera digital: [DIP-IAU, 2000].

Procesamiento de imagenes de bajo nivel:

• Muy poco uso de conocimiento respecto al conocimiento de imagenes.
• Adquisicion de la imagen, pre-procesamiento, segmentacion de la imagen, descripción y clasificacion del objeto.

Entendimiento de imagenes de alto nivel:

• Realizar tomas de desiciones respecto al conociemiento de las imagenes.

El procesamiento de imagenes esta dado por un conjunto de operaciones llevadas a cabo sobre las imagenes a fin de realizar mediciones cuantitativas para poder describirlas.

Una caracteristica es un atributo usado para hacer decisiones respecto a objetos en la imagen.

El poder realizar mediciones sobre las imagenes generalmente requiere que sus caracteristicas esten bien formadas, los bordes bien delimitados y el color y brillo sean uniformes.

Las herramientas para adquisicion de imagenes transforman la imagen visual de un objeto físico y sus caracteristicas intrinsecas en un conjunto de datos digitalizados, usados para procesarla.

En el procesamiento degital de imagenes, existen diversas aplicaciones y problemas:

• Representación
• Transformación
• Modelado
• Restauración
• Reconstrucción
• Análisis
• Comprensión de datos

Animación por computadora definición y caracteristicas:

La animación es la simulación de un movimiento, creada por la muestra de una serie de imágenes o cuadros. Un ejemplo sencillo de esto son las caricaturas, que pertenecen a la animación tradicional.

La animación por computadora se puede definir como un  formato de presentación digital en movimiento através de una secuencia de imágenes o cuadros creadas o generadas por la computadora se utiliza principalmente en videojuegos y peliculas.

Caracteristicas de la animación en 3D:

Una caracteristica importante de la animacion por computadora es que nos permite crear escenas "realmente" tridimensionales.

Otra ventaja de la animacion es que se puede reutilizar parates de la animación por separado. Incluso una animación puede verse muy diferente simplemente cambiando el angulo de la camara o cambiando el tiempo del moviemiento o de partes de la animación.

Hombre de Gengibre

Uso de la graficaión.

Graficos en la medicina:

Desde hace varios siglos, el hombre se ha venido apoyando en la imagen para conseguir aumentar la fiabilidad y la facilidad de su trabajo en el campo médico. Para ello ha utilizado diversas técnicas, significando cada una de ellas una auténtica revolución respecto a su predecesora. Uno de los “precursores” en el estudio científico y detallado del terreno de la medicina a través de la imagen fue Andreas Vesalio (1514-1564), primero con su “Tabulae Anatomicae Sex” (1538) y luego con una de las obras más importantes del s.XVI, la “De Humani Corporis Fabri” (1543):
La segunda gran revolución fue el descubrimiento y desarrollo de una técnica basada en los rayos X. 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.
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.
La Imagen Seccional por Resonancia Magnética (MRI funcional o fMRI), que persigue el desarrollo de un mapa cerebral (cartografía cerebral) mediante la detección de cambios de contraste causados por fluctuaciones del flujo sanguíneo y de la oxigenación de la hemoglobina, debido a estímulos externos visuales, auditivos, etc .

Graficos en educación:

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. No obstante, la mayor parte de los simulado-res cuenta con pantallas gráficas para la operación visual.

Graficos en 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.
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.

Graficación en entretenimiento:

En ocasiones, se despliegan sólo imágenes gráficas y otras veces, se combinan los objetos con los actores y escenas en vivo. Por ejemplo, en una escena gráfica creada para la película Start Treck - The Wrath of Khan, se dibujan en forma de armazón el planeta y la nave espacial y se sonbrean con métodos de presentación para producir superficies sólidas. Al igual que pueden aparecer personas en forma de armazón combinadas con actores y una escena en vivo. Los videos musicales aprovechan las gráficas de muchas maneras, se pueden combinar objetos gráficos con acción en vivo, o se pueden utilizar técnicas de procesamiento de imágenes para producir una transformación de una persona o un objeto en otro (morphing).

Fuentes de informacion:

http://www.puromarketing.com/24/9808/ejemplos-anuncios-publicidad-grafica-pondran-marcha-neuronas.html
http://www.mitecnologico.com/Main/BreveHistoriaDeLaGraficacion

Unidad IV "Iluminación y sombreado"

¿Como se colocan los rellenos de poligonos en OpenGL?
Para elegir el color de los polígonos, basta con hacer una llamada a glColor entre la definición de cada polígono.

glBegin(GL_TRIANGLES);
glColor3f(1.0f, 0.0f, 0.0f);
glVertex3f(0.0f,0.0f, 0.0f);     
glVertex3f(2.0f,0.0f, 0.0f);
glVertex3f(1.0f,1.0f, 0.0f); 
glColor3f(0.0f,1.0f, 0.0f);     
glVertex3f(-1.0f,0.0f, 0.0f);     
glVertex3f(-3.0f,2.0f, 0.0f);     
glVertex3f(-2.0f,0.0f, 0.0f);
glEnd();
  Tecnicas de sombrado clásicas y avanzadas.

Iluminación local:

Se denomina como luces que no son extensas, como las reales, sino inextensas, puntuales y son relacionadas con los objetos como mónedas aisladas, sin tener en cuenta la interacción entre ellos.

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 y la radiosidad.


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.

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.

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.

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.

Interpolación de Intensidades (Gouraud) 
Se basa en la interpolacion de intensidad o color que concidera que facetas planas vecinas proceden de aproximar una superficie curva, elimina en gran medida las discontinuidades de iluminacion. Es sencilla pero produce peores resultados en objetos con brillos espectaculares que el método de Phong implementado en OpenGL. 
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.

Circulos y Elipses

Circulos:
Utilizando B-Splines racionales, podemos dibujar circulos, elipses entre otras cosas bidimensionales. Además, se incluyen rutinas en el conjunto de herramientas de GLU (GLUT, OpenGL Utility Toolkit) que podemos utilizar para mostrar algunas cuádricas tridimencionales como esferas y conos y algunas otras formas geometricas.

Otro método que se puede utilizar para generar la grafica de una curva simple consiste en aproximarla utilizando una polilinea. Basta con localizarun conjunto de puntos a lo largo de la trayectoria y conectar dichos puntos mediante segmentos de lineas rectas. Cuantas mas secciones se incluyan mas suave sera la apariencia de la curva.

Puesto que el circulo es un componente muy frecuentemente utilizado en dibujos y gráficas, muchos paquetes gráficos incluyen un procedimiento para generar circulos completos o arcos circulares.

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.

La forma del circulo es similar en cada uno de los cuadrantes. Por tanto, si determinamos las posiciones de la curva en el primer cuadrante, podemos generar la sección circular del segundo cuadrante del plano i observando que ambas secciones son simétricas con respecto al eje y. 

Uno de los algoritmos que se pueden utilizar es el del punto medio que consiste en:

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 Calcular el valor inicial del parámetro de decisión
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+\
Determinar los puntos simétricos en los otros siete ociantes.
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
Repetir los Pasos 3 a 5 hasta que x > y.
Algoritmos para la generación de Elipces:

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.

Código Carro

Código:

#include <GL/glut.h>

GLfloat TrasX=0.0f;

GLfloat TrasY=0.0f;

GLfloat TrasZ=0.0f;

GLint ancho=400;

GLint alto=400;

int hazPerspectiva = 0;

void reshape(int width, int height)

{

    glViewport(0, 0, width, height);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    if(hazPerspectiva)

    gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);

     else

       glOrtho(-4,4, -4, 4, 1, 10);

    glMatrixMode(GL_MODELVIEW);

    ancho = width;

    alto = height;

}

void Piso(void)

{

    glColor3f(0.25f, 0.25f, 0.25f);

 glScalef(5.0f,0.0f,5.0f);

   

 glBegin(GL_QUADS);      

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

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

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

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

    glEnd();

}

void carro(void)

{

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

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

glBegin(GL_POLYGON); //carro

glVertex3f(-1.5f,0.5f, -2.0f);

glVertex3f( 3.5f,0.5f, -2.0f);

glVertex3f(3.5f,2.0f, -2.0f);

glVertex3f(2.0f,2.0f, -2.0f);

glVertex3f(1.f,3.0f, -2.0f);

glVertex3f(-0.5f,3.0f, -2.0f);

glVertex3f(-1.5f,2.0f, -2.0f);

glEnd();

}

void display()

{

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();

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

glRotatef(10, 1.0f, 0.0f, 0.0f);

glRotatef(10, 0.0f, 1.0f, 0.0f);

// dibuja piso

Piso();

// dibuja rueda

glLoadIdentity();

glTranslatef(3.0f,-1.5f,-1.0f);

glTranslatef(TrasX,TrasY,TrasZ);

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

glutSolidSphere(0.5f, 16, 16);

//dibuja 2da rueda

glLoadIdentity();

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

glLoadIdentity();

glTranslatef(TrasX,TrasY,TrasZ);

carro();

glLoadIdentity();

glTranslatef(-.5f,-1.5f,-1.0f);

glTranslatef(TrasX,TrasY,TrasZ);

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

glutSolidSphere(0.5f, 16, 16);

glFlush();

glutSwapBuffers();

}

void init()

{

    glClearColor(1,1,1,1);

    glEnable(GL_DEPTH_TEST);

    ancho = 400;

    alto = 400;

}

void idle()

{

    display();

}

void keyboard(unsigned char key, int x, int y)

{

    switch(key)

    {

    case 'p':

    case 'P':

  hazPerspectiva=1;

  reshape(ancho,alto);

 break;

    case 'o':

    case 'O':

  hazPerspectiva=0;

  reshape(ancho,alto);

 break;

    case 'a':

    case 'A':

  TrasX-=.10;

 break;

    case 's':

    case 'S':

  TrasX+=.10;

                break;

    }

}

int main(int argc, char **argv)

{

 glutInit(&argc, argv);

 glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

 glutInitWindowPosition(100, 100);

    glutInitWindowSize(ancho, alto);

    glutCreateWindow("Carro");

    init();

    glutDisplayFunc(display);

    glutReshapeFunc(reshape);

    glutIdleFunc(idle);

    glutKeyboardFunc(keyboard);

    glutMainLoop();

    return 0;

}

 Resultado:

 

¿Que hace el "glutLookAt"?

Es la funsión que determina dónde y como está dispuesta la cámara, cuidando la posición de la cámara no tiene nada que ver con el tipo de proyección que se haya definido.

La proyección se define sólo una vez al principio del programa regularmente, en una función inicializadora, mientras que la cámara que se mueve continuamente como al programador le interese y aun mas en 3D.

A esto no se le añade la función GL_PROYECTION sino que se le agrega el GL_MEDELVIEW.

En ese momento OpenGL se encargara de calcular las transformaciones que se aplican al mundo 3D manteniendo la camara en el origen de las coordenadas y enfocada en direccion negativa de Z para así darnos la sensación de verlo desde cierto lugar.

Para ello siempre se debe activar esta matriz antes de llamar a gluLookAt:

glMatrixMode(GL_MEDELVIEW);

La función GLTRASLATE se utiliza para mover de un punto a otro un objeto y la función GLUTAT se usa para visualizar el objeto.

No se comportan de la misma manera puesto que uno mueve el objeto y el otro mueve la cámara para visualizar el objeto.

Código a examinar:

Rotate on x
  glRotatef(rotY,0.0,1.0,0.0); // Rotate on y
 glRotatef(rotZ,0.0,0.0,1.0); // Rotate on z
 glTranslatef(X, Y, Z);  // Translates the screen left or right,    // up or down or zoom in zoom out
    // Draw the positive side of the lines x,y,z
    glBegin(GL_LINES);
    glColor3f (0.0, 1.0, 0.0); // Green for x axis
    glVertex3f(0,0,0);
    glVertex3f(10,0,0);
    glColor3f(1.0,0.0,0.0); // Red for y axis
    glVertex3f(0,0,0);
    glVertex3f(0,10,0);
    glColor3f(0.0,0.0,1.0); // Blue for z axis
    glVertex3f(0,0,0);
    glVertex3f(0,0,10);
    glEnd();
    // Dotted lines for the negative sides of x,y,z
glEnable(GL_LINE_STIPPLE);  // Enable line stipple to use a
    // dotted pattern for the lines
 glLineStipple(1, 0x0101);  // Dotted stipple pattern for the lines
  glBegin(GL_LINES);
    glColor3f (0.0, 1.0, 0.0);  // Green for x axis
    glVertex3f(-10,0,0);
    glVertex3f(0,0,0);
    glColor3f(1.0,0.0,0.0);  // Red for y axis
    glVertex3f(0,0,0);
    glVertex3f(0,-10,0);
    glColor3f(0.0,0.0,1.0);  // Blue for z axis
    glVertex3f(0,0,0);
    glVertex3f(0,0,-10);
    glEnd();
    glDisable(GL_LINE_STIPPLE);  // Disable the line stipple
    glPopMatrix();   // Don't forget to pop the Matrix
    glutSwapBuffers();
}
// This function is called whenever the window size is changed
void reshape (int w, int h)
{
    glViewport (0, 0, (GLsizei) w, (GLsizei) h); // Set the viewport
    glMatrixMode (GL_PROJECTION);  // Set the Matrix mode
    glLoadIdentity ();
    gluPerspective(75, (GLfloat) w /(GLfloat) h , 0.10, 100.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
// This function is used for the navigation keys
void keyboard (unsigned char key, int x, int y)
{
switch (key) {   // x,X,y,Y,z,Z uses the glRotatef() function
    case 'x': // Rotates screen on x axis
    rotX -= 0.5f;
    break;    case 'X': // Opposite way
    rotX += 0.5f;
    break;    case 'y': // Rotates screen on y axis
    rotY -= 0.5f;
    break;    case 'Y': // Opposite way
    rotY += 0.5f;
    break;
    case 'z': // Rotates screen on z axis
    rotZ -= 0.5f;
    break;    case 'Z': // Opposite way
    rotZ += 0.5f;
    break;
    // j,J,k,K,l,L uses the gluLookAt function for navigation   

    case 'j':
    rotLx -= 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;    case 'J':
    rotLx += 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;
    case 'k':
    rotLy -= 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;    case 'K':
    rotLy += 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;    case 'l':  // It has a special case when the rotLZ becomes
  // less than -15 the screen is viewed from the opposite side
    // therefore this if statement below does not allow rotLz be less than -15   
if(rotLz + 14 >= 0)
    rotLz -= 0.2f;          
    glMatrixMode(GL_MODELVIEW);   
    glLoadIdentity(); 
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;    case 'L':
    rotLz += 0.2f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt (rotLx, rotLy, 15.0 + rotLz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    break;    case 'b': // Rotates on x axis by -90 degree
    rotX -= 90.0f;
    break;    case 'B': // Rotates on y axis by 90 degree
    rotX += 90.0f;
    break;    case 'n': // Rotates on y axis by -90 degree
    rotY -= 90.0f;
    break;    case 'N': // Rotates on y axis by 90 degree
    rotY += 90.0f;
    break;    case 'm': // Rotates on z axis by -90 degree
    rotZ -= 90.0f;
    break;
    case 'M': // Rotates on z axis by 90 degree
    rotZ += 90.0f;
    break;    case 'o': // Default, resets the translations vies from starting view
    case 'O':
    X = Y = 0.0f;
    Z = 0.0f;
    rotX = 0.0f;
    rotY = 0.0f;
    rotZ = 0.0f;
    rotLx = 0.0f;
    rotLy = 0.0f;
    rotLz = 0.0f;
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(rotLx, rotLy, 15.0f + rotLz, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f); 
    break;}
    glutPostRedisplay(); // Redraw the scene
}
// called on special key pressed
void specialKey(int key, int x, int y) {
// The keys below are using the gluLookAt() function for navigation
// Check which key is pressed
switch(key) {
    case GLUT_KEY_LEFT : // Rotate on x axis
    X -= 0.1f;
    break;
    case GLUT_KEY_RIGHT : // Rotate on x axis (opposite)
    X += 0.1f;
    break;
    case GLUT_KEY_UP : // Rotate on y axis
    Y += 0.1f;
    break;
    case GLUT_KEY_DOWN : // Rotate on y axis (opposite)
    Y -= 0.1f;
    break;
    case GLUT_KEY_PAGE_UP: // Rotate on z axis
    Z -= 0.1f;
    break;
    case GLUT_KEY_PAGE_DOWN: // Rotate on z axis (opposite)
    Z += 0.1f;
    break;
}
    glutPostRedisplay(); // Redraw the scene
}
// Main entry point of the program
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);  // Setup display mode to
      // double buffer and RGB color
    glutInitWindowSize (600,600); // Set the screen size
    glutCreateWindow("OpenGL 3D Navigation Program");
    init ();
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard); // set window's key callback
    glutSpecialFunc(specialKey); // set window's to specialKey callback
    glutMainLoop();
    return 0;
}  

  

Graficacion 3D "Unidad 3"

Enlace 1:

Configuración:

instalación:

Hardware:

El API de OpenGL 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.

Windows:

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.

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.

Tutorial:

Qué es OpenGL?

Es una interfaz software de hardware gráfico. Es un motor 3D cuyas rutinas están integradas en tarjetas gráficas 3D.

OpenGL como máquina de estados:

Cuando se activan o configuran varios estados de la máquina, sus efectos perdurarán hasta que sean desactivados.

El pipeline de renderizado de OpenGL:

La mayor parte de las implementaciones de ogl siguen un mismo orden en sus operaciones, una serie de plataformas de proceso que, en su conjunto crean lo que se suele llamar el “OpenGL Rendering Pipeline”.

Escribir código basado en OpenGL:

Sintaxis:

Todas las funciones de ogl comienzan con el prefijo “gl” y las constantes con “GL_”. Como ejemplos, la función glClearColor() y la constante GL_COLOR_BUFFER_BIT.

En ogl existen 8 tipos distintos de datos, de una forma muy parecida a los tipos de datos de C o C++. Además, ogl viene con sus propias definiciones de estos datos (typedef en C).

Sufijo	Tipo de dato	Corresponde en C al tipo...	Definición en ogl del tipo
b	Entero 8-bits	signed char	GLbyte
s	Entero 16-bits	short	GLshort
i	Entero 32-bits	int o long	GLint, GLsizei
f	Punto flotante 32-bits	float	GLfloat, GLclampf
d	Punto flotante 64-bits	double	GLdouble, GLclampd
ub	Entero sin signo 8-bits	unsigned char	GLubyte, GLboolean
us	Entero sin signo 16-bits	unsigned short	GLushort
ui	Entero sin signo 32-bits	unsigned int	GLuint,GLenum, GLbitfield



Librerías relacionadas con OpenGL:

OpenGL contiene un conjunto de poderosos pero primitivos comandos de muy bajo nivel. Además la apertura de una ventana donde pintar, en el sistema grafico que utilicemos (win32, X11, etc.), no entra en el ámbito de OpenGL. Por eso las siguientes librerías son muy utilizadas en la programación de aplicaciones de ogl:

OpenGL Utility Library (GLU): contiene bastantes rutinas que usan ogl a bajo nivel para realizar tareas como transformaciones de matrices, para tener una orientación especifica, subdivisión de polígonos, etc.

GLX y WGL: GLX da soporte para máquinas que utilicen X Windows System, para inicializar una ventana, etc. WGL sería el equivalente para sistemas Microsoft.

OpenGL Utility Toolkit (GLUT): es un sistema de ventanas, escrito por Mark Kilgard, que es independiente del sistema de ventanas usado, dándonos funciones tipo abrir_ventana().

Hello Word:

#include <GL/glut.h>
void reshape(int width, int height){ glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1, 1, -1, 1, -1, 1); glMatrixMode(GL_MODELVIEW);} void display(){ glClear(GL_COLOR_BUFFER_BIT); glColor3f(1,1,1); glLoadIdentity(); glBegin(GL_TRIANGLES); glVertex3f(-1,-1,0); glVertex3f(1,-1,0); glVertex3f(0,1,0); glEnd(); glFlush();} void init(){ glClearColor(0,0,0,0);} int main(int argc, char **argv){ glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowPosition(50, 50); glutInitWindowSize(500, 500); glutCreateWindow("Hello OpenGL"); init(); glutDisplayFunc(display); glutReshapeFunc(reshape); glutMainLoop(); return 0;}

Dibujando en 3D:

El dibujo 3D en OpenGL se basa en la composición de pequeños elementos, con los que se va construyendo la escena deseada. Estos elementos se llaman primitivas. Todas las primitivas de ogl son objetos de una o dos dimensiones, abarcando desde simples puntos y líneas, a polígonos complejos. Las primitivas se componen de vértices, que no son más que puntos 3D. En este capítulo se pretende presentar las herramientas necesarias para dibujar objetos en 3D a partir de estas formas más sencillas. Para ello hay que deshacerse de la mentalidad en 2D de la computación gráfica clásica y definir el nuevo espacio de trabajo, ya en 3D.

Moviendonos por nuestro espacio en 3D:

#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f; 
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f; 
GLint ancho=400;

GLint alto=400;  

int hazPerspectiva = 0;  

void reshape(int width, int height){ 

    glViewport(0, 0, width, height); 

    glMatrixMode(GL_PROJECTION);     

    glLoadIdentity();     

    if(hazPerspectiva)      

           gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);

 else
           glOrtho(-4,4, -4, 4, 1, 10); 

     glMatrixMode(GL_MODELVIEW);      

     ancho = width;    alto = height; 

} 

 void drawCube(void){     

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

     glBegin(GL_QUADS);       //cara frontal     

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

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

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

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

     glEnd();     

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

    glBegin(GL_QUADS);       //cara trasera 

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

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

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

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

    glEnd(); 

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

    glBegin(GL_QUADS);       //cara lateral izq 

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

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

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

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

    glEnd(); 

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

    glBegin(GL_QUADS);       //cara lateral dcha 

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

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

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

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

    glEnd(); 

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

    glBegin(GL_QUADS);       //cara arriba     

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

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

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

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

   glEnd();  

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

   glBegin(GL_QUADS);       //cara abajo     

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

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

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

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

    glEnd(); 

}

void display(){ 

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);      

   glLoadIdentity();  

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

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

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

   drawCube();      

   glLoadIdentity();  

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

   glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f); 

   glTranslatef(3.0f, 0.0f, 0.0f);      

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

   glutWireSphere(0.5f, 8, 8);  

   glFlush();     

   glutSwapBuffers();      

   anguloCuboX+=0.1f; 

   anguloCuboY+=0.1f; 

   anguloEsfera+=0.2f; 

} 

void init(){     

   glClearColor(0,0,0,0); 

  glEnable(GL_DEPTH_TEST); 

  ancho = 400; 

  alto = 400;

} 
void idle(){ 

  display();

}

 void keyboard(unsigned char key, int x, int y){     

   switch(key)    {     

   case 'p': 

   case 'P':       

              hazPerspectiva=1;       

              reshape(ancho,alto); 

              break;  

    case 'o': 

    case 'O': 

                hazPerspectiva=0;       

                reshape(ancho,alto);       

                break;      

    case 27:   // escape       

                exit(0); 

                break; 

 } 

} 

 int main(int argc, char **argv){     

   glutInit(&argc, argv); 

   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); 

   glutInitWindowPosition(100, 100); 

   glutInitWindowSize(ancho, alto);     

   glutCreateWindow("Cubo 1");     

   init();     

   glutDisplayFunc(display);     

   glutReshapeFunc(reshape);     

   glutIdleFunc(idle); 

   glutKeyboardFunc(keyboard); 

   glutMainLoop(); 

   return 0; 

} 

Enlace 2:

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: m = [a1 ,a2 ,a3 ,a4 ,a5 ,a6 ,a7 ,a8 ,a9 ,a10, a11, a12, a13, a14, a15, a16]
es interpretada internamente por OpenGL como:

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.

void glGetFloatv(enum value, float *data); Permite obtener una copia de aquello que se indica en value. Por ejemplo si se pasan como parámetros MODELVIEW_MATRIX y un apuntador a un arreglo de flotantes tamaño 16 se obtiene una copia de dicha matriz a través del arreglo.

Enlace 3:

Proyección:

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

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)

glu ofrece una versión alternativa, mucho más fácil de entender:

void gluPerspective(GLdouble fov, GLdouble aspect, 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.

Enlace 4:

Enlace 5:

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

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

4.2.1 El modelador.

Se recogen las transformaciones del observador y del modelado.

4.2.1.2 Transformaciones del modelo.

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.

4.2.2 Transformaciones de la 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.

4.2.3 Transformaciones de la vista.

Proyectar lo que hemos dibujado en 3D al 2D de la pantalla, en la ventana en la que estamos trabajando. Esta es la denominada transformación de la vista.

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

4.3.1 El canal de transformaciones.

Beben modificarse dos matrices: la matriz del Modelador y la matriz de Proyección. Para activar una de las dos matrices utilizamos la función glMatrixMode. Hay dos parámetros posibles:

glMatrixMode(GL_PROJECTION);

y

glMatrixMode(GL_PROJECTION);

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

4.3.2.1 Translacion.

Los parámetros de glTranslate son las unidades a desplazar en el eje x, y y z, respectivamente. Pueden ser valores negativos, para trasladar en el sentido contrario.

4.3.2.2 Rotacion.

Para rotar, tenemos también una función de alto nivel que construye la matriz de transformación y la multiplica por la matriz activa, glRotate. Lleva como parámetros el ángulo a rotar (en grados, sentido horario), y después x, y y z del vector sobre el cual se quiere rotar el objeto.

4.3.2.3 Escalado.

Una transformación de escala incrementa el tamaño de nuestro objeto expandiendo todos los vértices a lo largo de los tres ejes por los factores especificados.

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

4.3.3.1 Proyección ortográfica.

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.

4.3.3.2 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 deformadas.