PREVIO #4

// OLIVERA RODRÍGUEZ GUSTAVO

#include

GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0}; /* Red diffuse light. */
GLfloat light_position[] = {0.0, 1.0, -1.0, 0.0}; /* Infinite light location. */
GLfloat n[6][3] = { /* Normals for the 6 faces of a cube. */
{-1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {1.0, 0.0, 0.0},
{0.0, -1.0, 0.0}, {0.0, 0.0, 1.0}, {0.0, 0.0, -1.0} };
GLint faces[6][4] = { /* Vertex indices for the 6 faces of a cube. */
{0, 1, 2, 3}, {3, 2, 6, 7}, {7, 6, 5, 4},
{4, 5, 1, 0}, {5, 6, 2, 1}, {7, 4, 0, 3} };
GLfloat v[8][3]; /* Will be filled in with X,Y,Z vertexes. */

int hazPerspectiva = 0;

int shoulder=0;
int joint=0;
int wrist=0;

void drawBox(void)
{
int i;

for (i = 0; i < 6; i++) {
glBegin(GL_QUADS);
glNormal3fv(&n[i][0]);
glVertex3fv(&v[faces[i][0]][0]);
glVertex3fv(&v[faces[i][1]][0]);
glVertex3fv(&v[faces[i][2]][0]);
glVertex3fv(&v[faces[i][3]][0]);
glEnd();
}
}

void brazo(int shoulder, int joint, int wrist)
{
//Empieza el modelado jerarquico de un robot

glPushMatrix();
glTranslatef(0.0,-0.0,0.0);
glPushMatrix();
glScalef(5.0,2.0,3.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,1.5,0.0);
glPushMatrix();
glScalef(2.5,1.0,3.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,1.5,0.0);
glPushMatrix();
glScalef(5.0,2.0,3.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(-3.5,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,2.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(-1.0,0.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,2.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(-1.5,0.0,0.0);
glPushMatrix();
glScalef(2.5,1.0,2.0);
drawBox();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(3.5,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,2.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(1.0,0.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,2.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(1.5,0.0,0.0);
glPushMatrix();
glScalef(2.5,1.0,2.0);
drawBox();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,1.5,0.0);
glPushMatrix();
glScalef(1.0,1.0,3.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,2.0,0.0);
glPushMatrix();
glScalef(3.0,3.0,3.0);
drawBox();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(-1.75,-3.5,0.0);
glPushMatrix();
glScalef(1.5,2.0,3.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,-2.0,0.0);
glPushMatrix();
glScalef(2.0,2.0,3.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,-2.0,0.0);
glPushMatrix();
glScalef(2.0,2.0,4.0);
drawBox();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(1.75,-3.5,0.0);
glPushMatrix();
glScalef(1.5,2.0,3.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,-2.0,0.0);
glPushMatrix();
glScalef(2.0,2.0,3.0);
drawBox();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,-2.0,0.0);
glPushMatrix();
glScalef(2.0,2.0,4.0);
drawBox();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();

}
display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
brazo(shoulder,joint,wrist);
glutSwapBuffers();
}

void
init(void)
{
/* Setup cube vertex data. */
v[0][0] = v[1][0] = v[2][0] = v[3][0] = -0.5;
v[4][0] = v[5][0] = v[6][0] = v[7][0] = 0.5;
v[0][1] = v[1][1] = v[4][1] = v[5][1] = -0.5;
v[2][1] = v[3][1] = v[6][1] = v[7][1] = 0.5;
v[0][2] = v[3][2] = v[4][2] = v[7][2] = 0.5;
v[1][2] = v[2][2] = v[5][2] = v[6][2] = -0.5;

/* Enable a single OpenGL light. */
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);

/* Use depth buffering for hidden surface elimination. */
glEnable(GL_DEPTH_TEST);

/* Setup the view of the cube. */
glMatrixMode(GL_PROJECTION);
gluPerspective( /* field of view in degree */ 110.0,
/* aspect ratio */ 1.0,
/* Z near */ 1.0, /* Z far */ 20.0);
glMatrixMode(GL_MODELVIEW);
gluLookAt(0.0, 0.0, 10.0, /* eye is at (0,0,5) */
0.0, 0.0, 0.0, /* center is at (0,0,0) */
0.0, 1.0, 0.0); /* up is in positive Y direction */

/* Adjust cube position to be asthetic angle. */
//glTranslatef(0.0, 0.0, -1.0);
glRotatef(20, 0.0, 0.0, 0.0);
//glRotatef(-20, 0.0, 0.0, 1.0);
}


int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(500,500);
glutCreateWindow("ROBOT");
glutDisplayFunc(display);
init();
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}

REPORTE DE PRÁCTICA #3

En está práctica aprendimos como usar las instrucciones glPushMatrix() y glPopMatrix() para manejar el stack y almacenar matrices de transformación para poder modelar de manera jerarquica un objeto.



void brazo(int shoulder, int joint, int wrist) {


//empieza el dibujo del primer brazo robot


glPushMatrix();


glTranslatef(-0.75,-0.5, 0.0);


glScalef(1.5,2.0,0.8);


drawBox();


glPopMatrix();


glPushMatrix();


glTranslatef(-0.75,1.0, 0.0);


drawBox();


glPopMatrix();


glPushMatrix();


//empieza el brazo


glRotatef(shoulder, 0.0, 0.0, 1.0);


glTranslatef(1.0, 0.0, 0.0);

glPushMatrix();

glScalef(2.0,0.5,0.5);

drawBox();

glPopMatrix();

//termina brazo

//empieza antebrazo

glTranslatef(1.0, 0.0, 0.0);

glRotatef(joint, 0.0, 0.0, 1.0);

glTranslatef(1.0, 0.0, 0.0);

glPushMatrix();

glScalef(2.0,0.5,0.5);

drawBox();

glPopMatrix();

//termina antebrazo-- M6

//empieza el grip

glPushMatrix();

//empieza el primer dedo

glPushMatrix();

glTranslatef(1.0,0.0,0.0);

glRotatef(wrist,0.0,0.0,1.0);

glTranslatef(0.35,0.125,0.0);

glPushMatrix();

glScalef(0.7,0.25,0.25);

drawBox();

glPopMatrix();

glPopMatrix();

//termina el primer dedo

//empieza el segundo dedo

glPushMatrix();

glTranslatef(1.0,0.0,0.0);

glRotatef(-wrist,0.0,0.0,1.0);

glTranslatef(0.35,-0.125,0.0);

glPushMatrix();

glScalef(0.7,0.25,0.25);

drawBox();

glPopMatrix();

glPopMatrix();

glPushMatrix();

glTranslatef(0.0,-1.0,0.0);

glPopMatrix();

//termina el segundo dedo

glPopMatrix();

//termina el grip

glPopMatrix();

//termina el dibujo del primer brazo robot

//empieza el brazo

glRotatef(shoulder, 0.0, 0.0, 1.0);

glTranslatef(-2.0, 0.0, 0.0);

glPushMatrix();

glScalef(2.0,0.5,0.5);

drawBox();

glPopMatrix();

//termina brazo

//empieza antebrazo

glTranslatef(-3.0, 0.0, 0.0);

glRotatef(joint, 0.0, 0.0, 1.0);

glTranslatef(1.0, 0.0, 0.0);

glPushMatrix(); glScalef(2.0,0.5,0.5);

drawBox(); glPopMatrix();

//termina antebrazo-- M6

//empieza el grip

glPushMatrix();

//empieza el primer dedo

glPushMatrix();

glTranslatef(1.0,0.0,0.0);

glRotatef(wrist,0.0,0.0,1.0);

glTranslatef(-2.35,0.125,0.0);

glPushMatrix();

glScalef(0.7,0.25,0.25);

drawBox();

glPopMatrix();

glPopMatrix();

//termina el primer dedo

//empieza el segundo dedo

glPushMatrix();

glTranslatef(1.0,0.0,0.0);

glRotatef(-wrist,0.0,0.0,1.0);

glTranslatef(-2.35,-0.125,0.0);

glPushMatrix();

glScalef(0.7,0.25,0.25);

drawBox();

glPopMatrix();

glPopMatrix();

glPushMatrix();

glTranslatef(0.0,-1.0,0.0);

glPopMatrix();

//termina el segundo dedo

glPopMatrix();

//termina el grip

glPopMatrix();

//termina el dibujo del segundo brazo robot

El fragmento de codigo anterior es un ejemplo claro de como podemos utilizar el stack para modelar jerarquicamente

Reporte_Practica2

Olivera Rodríguez Gustavo Computación Grafica
Reporte de Práctica #2:

1. Dibuje un cubo

/* start various header files needed */
#include <stdlib.h>
#include <math.h>
#define GLUT
#define GLUT_KEY
#define GLUT_SPEC
#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);
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;
}

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);
glutMainLoop();
return 0;
}
El resultado es el siguiente:

2. Dibuje una pirámide

Basándonos en el código anterior solo hay que modificar la función
drawCube() quedando de la siguiente manera:

void drawCube(void)
{
glColor3f(1.0f, 0.0f, 0.0f);
glBegin (GL_TRIANGLES);
glVertex3f (-1.0,1.0,0.0);
glVertex3f (1.0,1.0,0.0);
glVertex3f (0.0,-1.0,0.0);
glEnd ();

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

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

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

El resultado en pantalla es el siguiente:

3. DIBUJE UN TRIÁNGULO EN PANTALLA

Modificamos la función drawCube():

void drawCube(void)
{

glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_TRIANGLES);
glVertex2f( -5.5f, -2.0f);
glVertex2f(3.0f, -5.0f);
glVertex2f(3.0f, 7.0f);
glEnd();

}
Realizando lo anterior el resultado en pantalla es el siguiente:




4. DIBUJE UN PENTAGONO EN PANTALLA


Únicamente modificamos la función drawcube() otra vez:


void drawCube(void)
{
glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_POLYGON);
glVertex2f( -5.5f, -3.0f);
glVertex2f(5.5f, -3.0f);
glVertex2f(6.5f, 4.0f);
glVertex2f(0.0f, 7.0f);
glVertex2f(-6.5f, 4.0f);
glEnd();
}

5. DIBUJE UN PENTAGONO UTILIZANDO GL_POINTS

void drawCube(void)
{
glPointSize( 15.0); // modificamos el tamaño de los puntos
glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_POINTS);
glVertex2f( -5.5f, -3.0f);
glVertex2f(5.5f, -3.0f);
glVertex2f(6.5f, 4.0f);
glVertex2f(0.0f, 7.0f);
glVertex2f(-6.5f, 4.0f);
glEnd();

}

6. DIBUJE UN PENTAGONO UTILIZANDO GL_LINES

void drawCube(void)
{
glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_LINES); //cara trasera
glVertex2f( -5.5f, -3.0f);
glVertex2f( 5.5f, -3.0f);
glColor3f(1.0f,0.0f,0.0f);
glBegin(GL_LINES);
glVertex2f(6.5f, 4.0f);
glVertex2f(0.0f, 7.0f);
glEnd();
glColor3f(0.0f,1.0f,0.0f);
glBegin(GL_LINES);
glVertex2f(-6.5f, 4.0f);
glVertex2f( -5.5f, -3.0f);
glEnd();
glColor3f(1.0f,1.0f,0.0f);
glBegin(GL_LINES);
glVertex2f( 5.5f, -3.0f);
glVertex2f(6.5f, 4.0f);
glEnd();
glColor3f(1.0f,0.0f,1.0f);
glBegin(GL_LINES);
glVertex2f(-6.5f, 4.0f);
glVertex2f(0.0f, 7.0f);
glEnd();

}


7. DIBUJE UN PENTAGONO UTILIZANDO GL_LINE_STRIP

void drawCube(void)
{
glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_LINE_STRIP);
glVertex2f( -5.5f, -3.0f);
glColor3f(0.0f, 1.0f, 1.0f);
glVertex2f( 5.5f, -3.0f);
glColor3f(1.0f, 1.0f, 0.0f);
glVertex2f(6.5f, 4.0f);
glColor3f(1.0f, 0.0f, 0.0f);
glVertex2f(0.0f, 7.0f);
glColor3f(1.0f, 0.0f, 1.0f);
glVertex2f(-6.5f, 4.0f);
glColor3f(1.0f, 1.0f, 0.0f);
glVertex2f( -5.5f, -3.0f);
glEnd();

NOTA: Podemos observar la diferencia ya que a partir de dos vértices
que nos definen una línea, al agregar otro vértice se une al anterior
para formar una nueva.

8. DIBUJE UN PENTAGONO UTILIZANDO TRIANGULOS (GL_TRIANGLES)

void drawCube(void)
{

glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_TRIANGLES);
glVertex2f( -5.5f, -3.0f);
glVertex2f(0.0f, 7.0f);
glVertex2f(5.5f, -3.0f);
glEnd();
glColor3f(0.0f, 1.0f, 1.0f);
glBegin(GL_TRIANGLES);
glVertex2f( -5.5f, -3.0f);
glVertex2f(-6.5f, 4.0f);
glVertex2f(0.0f, 7.0f);
glEnd();
glColor3f(1.0f, 1.0f, 0.0f);
glBegin(GL_TRIANGLES);
glVertex2f( 5.5f, -3.0f);
glVertex2f(6.5f, 4.0f);
glVertex2f(0.0f, 7.0f);
glEnd();

}

9. DIBUJE UN PENTAGONO UTILIZANDO GL_TRIANGLE_STRIP

void drawCube(void)
{

glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_TRIANGLE_STRIP);
glVertex2f( -5.5f, -3.0f);
glVertex2f(5.5f, -3.0f);
glVertex2f( -6.5f, 4.0f);
glColor3f(0.0f, 1.0f, 1.0f);
glVertex2f( 6.5f, 4.0f);
glColor3f(0.0f, 1.0f, 1.0f);
glVertex2f( 0.0f, 7.0f);
glEnd();
}

Es similar a LINE_STRIPS, los primeros tres vértices generan un
triangulo y luego cada vértice adicional genera otro que comparte un
lado del triangulo anterior, es decir si se suministran los vértices
a,b,c,d,e se formarán los triángulos abc , cbd y cde

10. DIBUJE UN PENTAGONO UTILIZANDO GL_TRIANGLE_FAN

void drawCube(void)
{
glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_TRIANGLE_FAN);
glVertex2f( 0.0f, 7.0f);
glColor3f(0.0f, 1.0f, 1.0f);
glVertex2f( 6.5f, 4.0f);
glVertex2f(5.5f, -3.0f);
glVertex2f( -5.5f, -3.0f);
glVertex2f( -6.5f, 4.0f);
glEnd();

}

Esta primitiva genera un conjunto de triángulos alrededor de un punto
común, al igual que TRIANGLE_STRIPS, estos están conectados por un
lado. En este caso el proporcionar los vértices a,b,c,d,e generarán
los triángulos abc, acd y ade.

11. DIBUJE UN PENTAGONO UTILIZANDO CUADRILATEROS (GL_QUADS)

12. DIBUJE UN PENTAGONO UTILIZANDO GL_POLYGON
void drawCube(void)
{
glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_POLYGON);
glVertex2f( -5.5f, -3.0f);
glVertex2f(5.5f, -3.0f);
glVertex2f(6.5f, 4.0f);
glVertex2f(0.0f, 7.0f);
glVertex2f(-6.5f, 4.0f);
glEnd();
}

REPORTE DE PRÁCTICA #1

En esta práctica se nos dio una introducción a openGL que es la herramienta con la que estaremos trabajando a lo largo del curso, para ello tuvimos que descargar de la página de openGL la libreria GLUT

A continuación expongo paso a paso lo que hicimos en laboratorio:

quipo->propiedades->opciones avanzadas->variables de entorno->usuario->PATH ahí pegaremos la ruta de donde tenemos la DLL(Escritorio\Dev\Gl)

después en inicio->ejecutar->cmdponemos el comando echo %PATH% y debemos ver la ruta que agregamos

Del directorio glut37 nos interesa C:\Users\cursos20082\Desktop\glut37\glut-3.7\progs\demos\glutmech

abrimos visual studio->new project y en project types seleccionamos Visual c++->win32 y
seleccionamos win32 console application

ya estando en el proyecto dentro de visual studio->project->properties->configuration properties->linker->general y de lado derecho la opción additional library directories y poner C:\Users\cursos20082\Desktop\Dev\lib

en el explorador de soluciones-> source files y agregar glutmech.c de C:\Users\cursos20082\Desktop\glut37\glut-3.7\progs\demos\glutmech en el directorio del proyecto

volvemos ir a propiedades y en C/c++->general y en el lado derecho en aditional include directories C:\Users\cursos20082\Desktop\Dev\include

y finalmente compilamos el archivo glutmech.c para poder visualizar como es que se pueden manejar los gráficos con openGL.

PREVIO #2

1. ¿Qué es una transformación geométrica?

En el tratamiento y análisis de imágenes por computadora, es habitual la aplicación de transformaciones geométricas. Las transformaciones geométricas permiten la eliminación de la distorsión geométrica que se provoca cuando se captura una imagen.


Una transformación geométrica T es una función vectorial que asocia un pixel (x,y) a una nueva posición (x',y'). T se define con dos ecuaciones, una para cada componente:

La transformación geométrica, se realiza en dos pasos: En el primero, es la transformación de las coordenadas de los pixeles que asocia las coordenadas de un pixel de la imagen de entrada a un punto de la imagen de salida. Los puntos de salida pueden calcularse como valores continuos, ya que la posición final del punto no tiene porque coincidir con la rejilla digital después de la transformación tras la transformación. El segundo paso consiste en encontrar el punto de la rejilla digital que corresponde al punto transformado y en calcular su intensidad. La intensidad del punto suele ser calculada mediante la interpolación del brillo de varios puntos en la vecindad de dicho punto. Las transformaciones geométricas se encuentran en el límite entre las transformaciones de punto y las transformaciones locales.

• Transformación de las coordenadas de los pixeles

Una transformación geométrica aplicada a una imagen completa, puede cambiar el sistema de coordenadas, por lo que es necesario especificar el Jacobiano J que ofrece información sobre la forma en que se modifica el sistema de coordenadas:

¿Cuáles son las transformaciones básicas y sus matrices?

2. Escriba los comandos que en OpenGL permiten aplicar transformaciones geométricas, las variantes de dichos comandos y describa sus parámetros.

Las tres rutinas que proporciona OpenGL para definir transformaciones son glTranslate*, glRotate* y glScale*.

La rutina de traslación

void glTranslate{fd} (TYPE x, TYPE y, TYPE z);

Multiplica la matriz actual por una matriz de traslación con desplazamientos indicados por x, y, z.

La rutina de giro

void glRotate{fd} (TYPE angle, TYPE x, TYPE y, TYPE z);

Multiplica la matriz actual por una matriz que gira el objeto en el sentido contrario a las agujas del reloj (sentido de la mano derecha o dextrogiro) alrededor del eje que va desde el origen al punto indicado por x, y, z. Lo más habitual es girar sobre los ejes de coordenadas, por lo que los valores de los parámetros serán:

Giro sobre X: x = 1.0, y = 0.0, z = 0.0
Giro sobre Y: x = 0.0, y = 1.0, z = 0.0
Giro sobre Z: x = 0.0, y = 0.0, z = 1.0

Por último, la rutina de escalado

void glScale{fd} (TYPE x, TYPE y, TYPE z);

Multiplica la matriz actual por una matriz que amplia o reduce el objeto con respecto a los ejes coordenados. Cada coordenada (x, y, z) del objeto se multiplica por el argumento correspondiente x, y, z. Valores de estos parámetros inferiores a 1.0 reducen el objeto, mientras que valores superiores a 1.0 lo amplían.

Respecto al orden en que se aplican las transformaciones, supongamos que ejecutamos la siguiente porción de código OpenGL:

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(1.0, 1.0, 1.0);
glScalef(2.0, 2.0, 2.0);

Inicialmente, la matriz contiene la identidad, a la que llamaremos I. La orden gLTranslatef multiplica la identidad por una matriz de traslación a la que llamaremos T. Posteriormente, la orden gLScalef multiplica la matriz resultado por una matriz de escalado a la que llamaremos S. Por tanto, después de ejecutar el código la matriz de Modelo / Vista contiene el producto I·T·S. Cuando se aplique esta matriz a los distintos vértices del modelo tendremos:

v’ = I·T·S·v = I·(T·(S·v)))

es decir, primero se aplicará el escalado y posteriormente la traslación, por lo que podemos concluir que las transformaciones siempre se aplicarán en orden inverso al que han sido definidas en OpenGL.

3. Describa los comandos que en OpenGL se utilizan para definir vértices y sus parámetros. Escriba un ejemplo de cada uno.

Como especificar los vértices de un objeto

Los vértices son el denominador común en cualquiera de las primitivas de OpenGL. Con ellos se definen puntos, líneas y polígonos. La función que define vértices es glVertex, y puede tomar de dos a cuatro parámetros de cualquier tipo numérico. Por ejemplo, la siguiente línea de código define un vértice en el punto (10, 5, 3).

glVertex3f(10.0f, 5.0f, 3.0f);

Estos son otros ejemplos del uso de esta función:

glVertex2s (2, 3);

glVertex3d (1.0, 0.0, 3.1416);

Gldouble vect[3] = {5.0, 9.0, 12.0};
glVertex3dv (vect);

En el primer caso se especifican sólo dos coordenadas, en números enteros (short),
por lo que se asume que Z = 0. En el segundo se indican las tres coordenadas, pero en este
caso como números reales en doble precisión (double). Por último, en el tercer ejemplo se
define un vector de tres componentes de números reales en doble precisión y se le asignan las
coordenadas. Después se utiliza la versión de glVertex() que termina con el sufijo “v”.

4. ¿Para qué sirven los comandos glBegin() y glEnd()? Describa su uso, sus parámetros y ejemplifique a través de una pieza de código.

Para indicar el principio y el final del conjunto de vértices utilizaremos los comandos glBegin() y glEnd(), tal y como veremos a continuación.

Dibujo de primitivas geométricas

En la siguiente tabla, se muestran los posibles valores que pueden pasarse como parámetro del comando glBegin() y el correspondiente tipo de primitiva que se generará como resultado:

Valor

GL_POINTS: puntos individuales
GL_LINES: cada par de vértices un segmento de línea
GL_POLYGON :frontera de un polígono convexo
GL_TRIANGLES: cada tres vértices un triángulo
GL_QUADS: cada cuatro vértices un polígono de cuatro lados
GL_LINE_STRIP :serie de segmentos conectados
GL_LINE_LOOP: igual que la anterior pero une el último y el primero
GL_TRIANGLE_STRIP: triángulos adyacentes
GL_TRIANGLE_FAN: triángulos adyacentes con un vértice común
GL_QUAD_STRIP: polígonos de cuatro lados adyacentes

Una vez conocida la forma de especificar vértices, veremos como crear un conjunto de puntos, una línea o un polígono a partir de dichos vértices. Veamos un ejemplo para el polígono:

glBegin (GL_POLYGON);
glVertex2f (0.0, 0.0);
glVertex2f (0.0, 3.0);
glVertex2f (3.0, 3.0);
glVertex2f (4.0, 1.5);
glVertex2f (3.0, 0.0);
glEnd ();

5. Construya código para dibujar un cubo y una pirámide de base triángular (tetraedro). Las medidas corren por su cuenta.

Para el cubo:

glBegin (GL_QUADS);
glVertex3f (-1.0, -1.0,-1.0);
glVertex3f (-1.0,-1.0,1.0);
glVertex3f (1.0,-1.0,1.0);
glVertex3f (1.0,-1.0,-1.0);
glEnd ();

glBegin (GL_QUADS);
glVertex3f (-1.0, -1.0,-1.0);
glVertex3f (-1.0,-1.0,1.0);
glVertex3f (-1.0,1.0,1.0);
glVertex3f (-1.0,1.0,-1.0);
glEnd ();

glBegin (GL_QUADS);
glVertex3f (-1.0, -1.0,1.0);
glVertex3f (1.0,-1.0,1.0);
glVertex3f (-1.0,1.0,1.0);
glVertex3f (1.0,1.0,1.0);
glEnd ();

glBegin (GL_QUADS);
glVertex3f (1.0, -1.0,1.0);
glVertex3f (1.0,-1.0,-1.0);
glVertex3f (1.0,1.0,-1.0);
glVertex3f (1.0,1.0,1.0);
glEnd ();

glBegin (GL_QUADS);
glVertex3f (1.0, -1.0,-1.0);
glVertex3f (1.0,1.0,-1.0);
glVertex3f (-1.0,1.0,-1.0);
glVertex3f (-1.0,-1.0,-1.0);
glEnd ();

glBegin (GL_QUADS);
glVertex3f (-1.0, 1.0,-1.0);
glVertex3f (-1.0,1.0,1.0);
glVertex3f (1.0,1.0,1.0);
glVertex3f (1.0,1.0,-1.0);
glEnd ();

Para el tetraedro:

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

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

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

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

6. ¿Para qué sirven los comandos glClearColor() y glClear()? Descríbalos su funcionamiento, sus parámetros y ejemplifique a través de una pieza de código.

glClearColor() Da los valores de alfa, azul, verde y rojo
glClear() utiliza los valores de glClearColor para limpiar la pantalla

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

7. Describa los comandos

glutInit(), glutInitDisplayMode(), glutInitWindowSize(),glutInitWindowPosition(),

glutCreateWindow(), glutDisplayFunc(), glutReshapeFunc(), glutKeyboardFunc()

y glutMainLoop(). Describa su funcionamiento, usi y parámetros

glutInit() Inicializa la librería de GLUT. Se utiliza de la siguiente manera: void glutInit(int *argcp, char **argv); extrae cualquier opción de comando entendida por la librería de GLUT.
glutInitDisplayMode () Fija el modo de display inicial.
void glutInitDisplayMode(unsigned int mode); el valor entero que se utiliza de argumento funciona como un selector de las máscaras del modo de despliegue.
glutInitWindowSize () Fija el tamaño inicial de la ventana.
void glutInitWindowSize(int width, int height); 
glutInitWindowPosition () Especifica la posición de la ventana.
void glutInitWindowPosition(int x, int y); 
glutCreateWindow () Crea una ventana.
int glutCreateWindow(char *name); 
glutDisplayFunc() Obtiene el callback de display para la ventana actual. Esta función callback especifica cuál función será llamada cada vez que la ventana actual se afecte void glutDisplayFunc(void (*func)(void));
glutReshapeFunc() Especifica cuál función será llamada cada vez que la ventana sea alterada,

void glutReshapeFunc(void (*func)(int width, int height)); func es la nueva función que se llama cuando hay alguna alteracion

glutKeyboardFunc() Accion a realizar cada vez que se pulsa una de las teclas

void glutKeyboardFunc(void (*function)(unsigned char key, int x, int y)); El argumento function es un puntero a la función que actúa como rutina de servicio. Parámetros, el carácter de la tecla pulsada y la posición del ratón sobre la ventana en coordenadas del mundo real.

glutMainLoop() Procesamiento del GLUT en un ciclop infinito, una vez llamado nunca se saldrá del proceso,

void glutMainLoop(void);