MODIFICACIÓN DEL CUBO EN 3D

#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;

GLint ancho=600;
GLint alto=600;

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);
 glTranslatef(-3,0,0);
    glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);
    glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);
glScalef(0.5f, 0.5f, 0.5f);
    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 = 600;
    alto = 600;
}


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(display);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}

Corrida

PELOTA QUE REBOTA EN 2D

#include <gl/glut.h>
#include <Math.h>    
#define PI 3.14159265f   

char title[] = "Pelota que Rebota 2D";
int windowWidth  = 640;    
int windowHeight = 480;    
int windowPosX   = 50;    
int windowPosY   = 50;    
 
GLfloat ballRadius = 0.2f;  
GLfloat xPos = 0.0f;      
GLfloat yPos = 0.0f;
GLfloat xPosMax, xPosMin, yPosMax, yPosMin;
GLdouble xLeft, xRight, yBottom, yTop;    
GLfloat xSpeed = 0.004f;
GLfloat ySpeed = -.007f;
int refreshMillis = 5;    
     

void initGL() {
   glClearColor(0.0, 0.0, 0.1f, 1.0);
}
 
void display() {

   glClear(GL_COLOR_BUFFER_BIT);  
 
   glLoadIdentity();              
   glTranslatef(xPos, yPos, 0.0f);
 
   glBegin(GL_TRIANGLE_FAN);
      glColor3f(0.0f, 0.0f, 1.0f);
      glVertex2f(0.0f, 0.0f);      
      int numSegments = 100;
      GLfloat angle;
      for (int i = 0; i <= numSegments; i++) {
         angle = i * 2.0f * PI / numSegments;
         glVertex2f(cos(angle) * ballRadius, sin(angle) * ballRadius);
      }
   glEnd();
   glutSwapBuffers();  
   xPos += xSpeed;
   yPos += ySpeed;
 
   if (xPos > xPosMax) {
      xPos = xPosMax;
      xSpeed = -xSpeed;
   } else if (xPos < xPosMin) {
      xPos = xPosMin;
      xSpeed = -xSpeed;
   }
   if (yPos > yPosMax) {
      yPos = yPosMax;
      ySpeed = -ySpeed;
   } else if (yPos < yPosMin) {
      yPos = yPosMin;
      ySpeed = -ySpeed;
   }

}
void reshape(GLsizei weight, GLsizei height) {
   if (height == 0) height = 1;              
   GLfloat aspect = (GLfloat)weight / height;  
 
   glViewport(0, 0, weight, height);
    
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();          
   if (weight <= height) {
      xLeft   = -1.0;
      xRight  = 1.0;
      yBottom = -1.0 / aspect;
      yTop    = 1.0 / aspect;
   } else {
      xLeft   = -1.0 * aspect;
      xRight  = 1.0 * aspect;
      yBottom = -1.0;
      yTop    = 1.0;
   }
   gluOrtho2D(xLeft, xRight, yBottom, yTop);
   xPosMin = xLeft + ballRadius;
   yPosMax = yTop - ballRadius;  
   xPosMax = xRight - ballRadius;
   yPosMin = yBottom + ballRadius;
 
 
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();          
}
void Timer(int value) {
glutPostRedisplay();  
glutTimerFunc(refreshMillis, Timer, 0);
}

int main(int argc, char** argv) {
   glutInit(&argc, argv);          
   glutInitDisplayMode(GLUT_DOUBLE);
   glutInitWindowSize(windowWidth, windowHeight);
   glutInitWindowPosition(windowPosX, windowPosY);
   glutCreateWindow(title);    
   glutDisplayFunc(display);    
   glutReshapeFunc(reshape);    
   glutTimerFunc(0, Timer, 0);  
   initGL();                    
   glutMainLoop();              
   return 0;
}

Corrida

Cubo 3D

#include <GLglut.h>

GLfloat anguloCuboY;

void drawCube(void)
{
      glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_QUADS);       //cara frontal
glVertex3f(  0.0f,  0.0f,0.0f);  //0
glVertex3f(100.0f,  0.0f,0.0f); //1
glVertex3f(100.0f,100.0f,0.0f); //2
glVertex3f(  0.0f,100.0f,0.0f);   //3

    glEnd();

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

    glBegin(GL_QUADS);       //cara trasera
    glVertex3f(  0.0f,100.0f,-100.0f); //6
glVertex3f(100.0f,100.0f,-100.0f); //5
glVertex3f(100.0f,  0.0f,-100.0f); //4
glVertex3f(  0.0f,  0.0f,-100.0f); //7

    glEnd();

    glColor3f(0.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara lateral izq
    glVertex3f(100.0f,  0.0f,   0.0f); //1
glVertex3f(100.0f,  0.0f,-100.0f); //4
glVertex3f(100.0f,100.0f,-100.0f); //5
glVertex3f(100.0f,100.0f,   0.0f); //2

    glEnd();

    glColor3f(1.0f, 1.0f, 0.0f);
    glBegin(GL_QUADS);       //cara lateral dcha
    glVertex3f(0.0f,100.0f,   0.0f);   //3
    glVertex3f(0.0f,100.0f,-100.0f); //6
glVertex3f(0.0f,  0.0f,-100.0f); //7
glVertex3f(0.0f,  0.0f,   0.0f);  //0

    glEnd();

    glColor3f(0.0f,1.0f, 1.0f);
    glBegin(GL_QUADS);       //cara arriba
   
glVertex3f(100.0f,100.0f,-100.0f); //5
glVertex3f(  0.0f,100.0f,-100.0f); //6
glVertex3f(  0.0f,100.0f,   0.0f);   //3
glVertex3f(100.0f,100.0f,   0.0f); //2

    glEnd();

    glColor3f(1.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara abajo
     glVertex3f( 0.0f,0.0f,-100.0f); //7
glVertex3f(100.0f,0.0f,-100.0f); //4
glVertex3f(100.0f,0.0f,   0.0f); //1
glVertex3f(  0.0f,0.0f,   0.0f);  //0

    glEnd();

}

void myinit(void)
{

/* attributes */


glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-150,150,-150,150,1,500.0);

glMatrixMode(GL_MODELVIEW);


}
void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);

}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f,0.0f,-150.0f);
   
    glRotatef(45,0.0f,0.0f,1.0f);
glRotatef(anguloCuboY, 1.0f,1.0f,0.0f);

drawCube();

    glFlush();

anguloCuboY+=0.1f;

}

int main(int argc, char** argv)
{
        glutInit(&argc, argv);
   
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
        glutInitWindowSize(650, 650);
        glutCreateWindow("Cubo 3D");
         init();
        glutDisplayFunc(display);
myinit();
glutIdleFunc(display);
        glutMainLoop();
return 0;
}

Proyección Ortogonal

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

También son las encargadas de mover, rotar y escalar objetos. En realidad, estas transformaciones no se aplican a los modelos en sí, si no al sistema de coordenadas, de forma que si se quiere rotar un objeto, no lo se le rota, sino que se rota el eje sobre el que se sitúa.

En esta sección se recogen las transformaciones del observador y del modelado puesto que, como se verá en el apartado 4.2.1.3, 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.

 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. A efectos prácticos, esta translación especifica cómo se traslada una escena finalizada a la imagen final de la pantalla.

 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. Por tanto todas las transformaciones ejecutables con ogl pueden describirse como la multiplicación de dos o más matrices.

 El canal de transformaciones

 OpenGL proporciona muchas funciones de alto nivel que hacen muy sencillo la construcción de matrices para transformaciones. Éstas se aplican sobre la matriz que este activa en ese instante. Para activar una de las dos matrices utilizamos la función glMatrixMode. Hay dos parámetros posibles:

glMatrixMode(GL_PROJECTION);

activa la matriz de proyección, y

glMatrixMode(GL_MODELVIEW);

activa la del modelador. 

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. Si se multiplica la matriz del vértice (de tamaño 1x4) por ésta se obtiene otra matriz 1x4 con los vértices transformados sobre ese sistema de coordenadas.

 Translación

Imaginemos que se quiere dibujar un cubo con la función de la librería GLUT glutSolidCube, que lleva como parámetro el lado del cubo. Si se escribe el siguiente código:

glutSolidCube(5);

se obtiene un cubo centrado en el origen (0,0,0) y con el lado de la arista 5.

glTranslatef(10.0f, 0.0f, 0.0f);

glutSolidCube(5);

La “f” añadida a la función indica que se usarán flotantes. 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.

Rotación

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. Una rotación simple, sobre el eje y, de 10º sería

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

 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. La función glScale lleva como parámetros la escala en x, y y z, respectivamente. El valor 1.0f es la referencia de la escala, de tal forma que la siguiente línea:

glScalef(1.0f, 1.0f, 1.0f);

no modificaría el objeto en absoluto. Un valor de 2.0f sería el doble, y 0.5f sería la mitad. Por ejemplo, para ensanchar un objeto a lo largo de su eje z, de tal forma que quedase cuatro veces más “alargado” en este eje, sería:

glScalef(1.0f, 1.0f, 4.0f);

La matriz de proyección

La matriz de proyección especifica el tamaño y la forma del volumen de visualización. Está delimitado por una serie de planos de trabajo. De estos planos, los más importantes son los planos de corte, que son los que nos acotan el volumen de visualización por delante y por detrás. Todo lo que esté más adelante del plano de corte más alejado de la cámara (zfar) no se representa.

 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.

Para definir la matriz de proyección ortográfica y multiplicarla por la matriz activa (que debería ser en ese momento la de proyección, GL_PROJECTION), se utiliza la función glOrtho, que se define de la siguiente forma:

glOrtho(limiteIzquierdo, limiteDerecho, limiteAbajo, limiteArriba, znear, zfar)

siendo todos flotantes.

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.

Ejemplo: una escena simple

Código

El siguiente código es un programa que usa OpenGL mediante la librería GLUT. Primero se lista el código completo y luego se comenta línea por línea. Con él se aplicará lo aprendido en el anterior capítulo y el presente, además de nuevas funciones de la librería GLUT.

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

}

1. ¿Puede diferenciar entre los dos tipos de proyección?

La ortogonal aun que pareciera que es 3D en realidad solo es 2D  tiene un único ángulo de visión y en perspectiva la profundidad con que se ve la imagen depende del ángulo de visión.

2. ¿Entiende para que se usan las matrices y como las maneja opengl? explíquelo.

Se usan para hacer operaciones con vectores y dependiendo que se desee lograr se utiliza una propiedad diferente de las matrices, ya sea rotación, traslación, etc..

3. ¿Qué es la matriz identidad y para que se utiliza en opengl?

Cumple con la propiedad de ser el elemento neutro del producto de matrices, podría ser utilizada multiplicándola con un escalar y hacer una estalación con otra matriz vectores

5. explique las diferencias

La diferencia sería que el primer cubo sin rotar se ve como si fuera en 2D por que solo se ve una cara  y en perspectiva, ya nos podríamos dar cuenta de la profundidad del objeto y verlo en 3D

Transformaciones Geométrica

En este capítulo se hace un breve repaso de transformaciones geométricas en 2D y 3D que son ampliamente conocidas y su extensión a otras dimensiones. Existen varias transformaciones geométricas, pero solo se revisan el escalamiento, la translación y la rotación.

Escalamiento

El escalamiento permite cambiar el tamaño de un objeto expandiéndolo o contrayéndolo en sus dimensiones.

Escalamiento 2D

El escalamiento 2D implica el cambio de tamaño de un polígono, donde cada punto  es transformado por la multiplicación de dos factores de escalamiento:  a lo largo de los ejes  respectivamente. De esta forma, las coordenadas del nuevo punto se obtienen como:

                                                 x1 ' = x1 · s1

                                                 x2 ' = x2 · s2

Sea   s = (s1, s2)   el   vector   de   factores   de   escalamiento,   y   S(s)   la   matriz   de escalamiento, en coordenadas homogéneas el escalamiento de un punto p en 2D se puede expresar como el producto matricial  p' = p ⋅ S (s), es decir:

La Figura 3.1 muestra el efecto de escalamiento de una figura con s1 = 1.5 y  s2 = 2.

Escalamiento 3D

Extendiendo la idea anterior a 3D, el escalamiento implica el cambio de tamaño de un poliedro, donde cada punto  p = (x1, x2, x3)  es transformado por la multiplicación de tres factores de escalamiento: s1, s2 y s3 a lo largo de los ejes X1, X2 y X3 respectivamente, de esta forma, las coordenadas del nuevo punto  p' = (x1 ', x2 ', x3 ' ) se obtienen como:

                                  x1 ' = x1 ⋅ s1

                                  x2 ' = x2 ⋅ s2

                                  x3 ' = x3 ⋅ s3

Sea   s = (s1 , s2 , s3 )   el  vector  de  factores  de  escalamiento,  y  S(s)  la  matriz  de escalamiento, en coordenadas homogéneas el escalamiento de un punto p en 3D se puede expresar como el producto matricial  p' = p ⋅ S (s) , es decir:

La Figura 3.2 muestra el efecto de escalamiento de una figura con s1 = 2, s2 = 2.5  y s3 = 1.5.

Translación

La  translación  permite  desplazar  un  objeto  a  lo  largo  de  sus  dimensiones,  como resultado se obtiene un cambio de posición.

Translación 2D

La  translación  2D  implica  el  desplazamiento  de  un  polígono,  donde  cada  punto p = (x1 , x2 )  es trasladado d1 unidades en el eje X1 y d2 unidades en el eje X2, de esta forma, las coordenadas  del nuevo punto  p' = (x1 ', x2 ' ) , se obtienen como:

                         x1 ' = x1 + d1

                         x2 ' = x2 + d 2

Sea   d = (d1 , d 2 )   el  vector  de  distancias,  y  T(d)  la  matriz  de  translación,  en coordenadas homogéneas la translación de un punto p en 2D se puede expresar como el producto matricial  p' = p ⋅ T (d ) , es decir:

La Figura 3.3 muestra el efecto de translación de una figura con d1 = 1 y  d2 = 2.

Translación 3D

Basándose   en   la   idea   anterior,   se   tiene   que   la   translación   3D   implica   el desplazamiento de un poliedro, donde cada punto  p = (x1 , x2 , x3 ) es trasladado d1 unidades en el eje X1 , d2 unidades en el eje X2 y d3 unidades en el eje X3, de esta forma, las coordenadas del nuevo punto  p' = (x1 ', x2 ', x3 ' ) se obtienen como:

                                    x1 ' = x1 + d1

                                    x2 ' = x2 + d 2

                                    x3 ' = x3 + d3

Sea  d = (d1 , d 2 , d3 )   el  vector  de  distancias,  y  T(d)  la  matriz  de  translación,  en coordenadas homogéneas la translación de un punto p en 3D se puede expresar como el producto matricial  p' = p ⋅ T (d ) , es decir:

La Figura 3.4 muestra el efecto de translación de una figura con d1 = 2, d2 = 0 y d3 = 2.

Rotación

La rotación permite girar un objeto sobre un eje de rotación, dado un valor de ángulo de rotación 0 y su dirección.

Rotaciones 2D

La rotación de un objeto en 2D se lleva a cabo alrededor de un punto, que es el eje puntual (cero-dimensional) de rotación. Las rotaciones principales 2D son aquellas que se llevan a cabo alrededor del origen, las rotaciones sobre cualquier otro punto arbitrario se llaman  rotaciones  generales  2D.  En  esta  Sección  3.5  ,  se  analizan  sólo  las  rotaciones principales  para  todas  las  dimensiones,  en  la  Sección  3.6 se  discuten  las  rotaciones generales.

Para generar una rotación, se especifica el ángulo de rotación 0, y el punto de rotación (pivote) sobre el cual el objeto será rotado. Los ángulos de rotación positivos definen una rotación en sentido contrario a las manecillas del reloj sobre el punto pivote (del eje X1 al eje X2), entonces los ángulos de rotación negativos producen una rotación en el sentido de las manecillas (del eje X2 al eje X1). [Hearn 95] describe la rotación 2D como el giro sobre el eje de rotación que es perpendicular al plano X1X2 (mejor conocido como plano XY) y que pasa a través del punto pivote.

Si el punto pivote se encuentra sobre el origen (Figura 3.5), se tiene que: r es la distancia del punto  p = (x1, x2 )  al origen, 0 define la posición angular del punto p desde la horizontal, y 0 el ángulo de rotación de p para producir el nuevo punto p' = (x1 ', x2 ' ) .

Utilizando  coordenadas  polares,  el  punto   p = (x1 , x2 )   se  puede  escribir  como p = (r, Ø )  y el punto  p' = (x1 ', x2 ' )  como  p' = (r, Ø + 0 ) . Pasando después estos puntos de coordenadas polares a rectangulares se tiene que:

            x1 = r cos(Ø )

           x1 ' = r cos(Ø + 0 )

           x2 = r sin(Ø )

          x2 ' = r sin(Ø + 0 )

 Aplicando algunas propiedades trigonométricas:

                       x1 ' = r cos(Ø + 0 ) = r cosØ cos0 − r sin Ø sin0

                      x2 ' = r sin(Ø + 0 ) = r cosØ sin0 + r sin Ø cos 0   

         

 Substituyendo los valores de  x1 = r cos(Ø )  y  x2 = r sin(Ø ) se obtienen las ecuaciones para rotar un punto  p = (x1, x2 ) alrededor del origen dado un ángulo Ø:

                                 x1 ' = x1 cos 0 − x2 sin 0

                                 x2 '= x1 sin 0+ x2 cos0

Ecuación 3.9: Formulas para la rotación 2D alrededor del origen.

Sea  R(0)  la  matriz  de  rotación  sobre  el  origen,  en  coordenadas  homogéneas  la rotación de un punto p alrededor del origen en 2D se puede expresar como el producto matricial  p' = p ⋅ R(0 ) , es decir:

Ecuación 3.10: Expresión matricial para la rotación 2D.

La Figura 3.6 muestra el efecto de rotación de una figura con 0 = 45°.

Rotaciones 3D

A diferencia de la rotación en el espacio 2D, donde para hacer rotar un objeto se necesita un punto (cero-dimensional), en 3D para hacer rotar un objeto se necesitan dos puntos no coincidentes que determinan un segmento de recta, cuya línea de soporte define un eje lineal (uni-dimensional) de rotación.

Las rotaciones principales 3D, son aquellas cuando el eje de rotación se encuentra sobre alguno de los tres ejes principales: X1, X2 o X3, las rotaciones sobre cualquier otro eje arbitrario son llamadas rotaciones generales 3D. Se recuerda que inicialmente, se analizan las rotaciones principales.

Por convención, los ángulos de rotación positivos producen rotaciones en contra de las manecillas del reloj sobre el eje de rotación, esto es si se observa el giro desde la parte positiva del eje hacia el origen. Otra forma de determinar la dirección de un giro positivo es mediante la regla de la mano derecha (Figura 3.7), que dice que: “Si se coloca el dedo pulgar de la mano derecha sobre el eje de rotación apuntando hacia la parte positiva de dicho eje, el giro natural del resto de los dedos indica la dirección positiva del giro”.

Para entender el concepto de rotación en 3D como una extensión de la rotación 2D, hay que recordar que la rotación 2D es el giro sobre el eje de rotación, que es perpendicular al plano X1 X2, el cual en 3D corresponde al eje X3, entonces se tiene la primera de las rotaciones principales.

De esta forma, por cada punto  p = (x1 , x2 , x3 )  dado un ángulo 0, puede ser rotado sobre el eje X3 en sentido contrario a las manecillas del reloj, obteniendo las coordenadas del nuevo punto  p' = (x1 ', x2 ', x3 ' ) de la misma forma en cómo se analizó en el espacio 2D, quedando la coordenada x3 sin cambio, entonces, se extienden las formulas para la rotación 2D  a 3D como:

                          x1 ' = x1 cos 0 − x2 sin 0

                          x2 ' = x1 sin 0 + x2 cos 0

                          x3 ' = x3

              Ecuación 3.11: Fórmulas para la rotación 3D alrededor del eje X3.

Sea R3(0) la matriz de rotación alrededor del eje X3, en coordenadas homogéneas la rotación de un punto p alrededor de dicho eje, se puede expresar como el producto matricial p' = p ⋅ R3 (0 ) , es decir:

La Figura 3.8 muestra el efecto de rotación sobre el eje X3 de una figura con 0 = 20°.