viernes, 24 de febrero de 2012

Resumen capitulo 2


Transformaciones geométricas.
Habitualmente un paquete gráfico permite al usuario especificar que parte de una imagen definida se debe de visializar y donde esta parte se debe colocar en el dispositivo del visualización. Se compone por coodenadas.


Transformaciones bidimensionales.
Traslacion:En un objeto para cambiar su posicion a lo largo de la trayectoria  de una linea recta de una direccion de coordenadas a otra. Asi que se convierte al agregar distancias de traslacion t y t con (x’ = x + tx’) o (y’ = y + ty), en  ocasiones las ecucaciones de transformación matricianal se expresan en terminos de vectores en renglon de coordenadas en vez de vectores de columna.
Los poligonos se trasladas al sumar el vector de traslacion a la posición de coordenadas.



Rotación: Se aplica una rotación bidimensional en un objeto al cambiar su posición a lo largo de la trayectoria de una circunferencia en el plano de xy, para generar una rotación especificamos un angulo y la posición del punto de rotación en torno el cual se girara el objeto

Eslacion: Es una transformación de escalacion la cual altera el tamaño de un objeto. Se puede realizar esta operación para polígonos al multiplicar los valores de coordenadas de cada vértice por los factores de escalacion para producir coordenadas transformadas.

Coordenadas homogéneas y representación matricial
En las aplicaciones de diseño y de creación de imágenes, realizamos traslaciones, rotaciones y  escalaciones para ajustar los componentes de la imagen en sus posiciones apropiadas. En este tema consideramos cómo se pueden volver a formular las representaciones de la matriz de modo que se pueden procesar de manera eficiente esas secuencias de transformación.

Composición de transformaciones bidimensionales.
Con las representaciones de matriz del tema anterior, podemos establecer una matriz para cualquier secuencia de transformaciones como una matriz de transformación compuesta al calcular  el producto de la matriz de las transformaciones individuales. 
P y P’ como vectores de columna de coordenadas homogéneas. Podemos verificar este resultado al calcular el producto de la matriz para las dos agrupaciones asociativas. Asimismo, la matriz de transformación compuesta para esta secuencia de transformaciones es:

Formula equivalente para lograr la rotación

Formula equivalente para lograr la escalacion.

Rotacion del punto pivote general
Se necesitan seguir 3 pequeños pasos a gran escala para desarrollarla.
1. Traslade el objeto de modo que se mueva la posición del punto pivote al origen de  las coordenadas.
2. Gire el objeto con respecto del origen de las coordenadas.
3. Traslade el objeto de manera que se regrese el punto pivote a su posición original.


Escalacion del punto fijo general
Son una conjunto de secuencias las cuales se especifican en el siguiente dibujo.
1. Traslade el objeto de modo que el punto fijo coincida con el origen de las coordenadas.
2. Escale el objeto con respecto del origen de las coordenadas
3. Utilice la traslación inversa del paso 1 para regresar el objeto a su posición original.


Transformación ventana-área de vista.
Algunos paquetes gráficos permiten que el programador especifique coordenadas de primitivas de salida en un sistema de coordenadas de mundo de punto flotante, usando las unidades que sean relevantes para el programa de aplicación: angstroms, micras, metros, millas, años luz, etcétera. Se emplea el término de mundo porque el programa de aplicación representa un mundo que se crea o presenta interactivamente para el usuario.

Transformaciones de composición general y de eficiencia computacional.
Una transformación bidimensional general, que representa una combinación de traslaciones rotaciones y escalaciones se puede expresar como una matriz de 3x3.
Así como las transformaciones bidimensionales se pueden representar con matrices de 3x3 usando coordenadas homogéneas, las transformaciones tridimensionales se pueden representar con matrices de 4x4, siempre y cuando usemos representaciones de coordenadas homogéneas de los puntos en el espacio tridimensional.

Así, en lugar de representar un punto como (x,y,z), lo hacemos como (x, y, z, W), donde dos de estos cuádruplos representan el mismo punto si uno es un multiplicador distinto de cero del otro.
Las transformaciones geométricas son transformaciones afines. Esto es, pueden expresarse como una función lineal de posiciones de coordenadas. Traslación, rotación y escalación son transformaciones afines. Transforman líneas paralelas en líneas paralelas y posiciones de coordenadas finitas en posiciones finitas.

Representación matricial de transformación tridimensionales.
Así como las transformaciones bidimensionales se pueden representar con matrices de3 X 3 usando coordenadas homogéneas, las transformaciones tridimensionales se puedenrepresentar con matrices de 4 X 4, siempre y cuando usemos representaciones decoordenadas homogéneas de los puntos en el espacio tridimensional. Así, en lugar derepresentar un punto como (
x, y, z ), lo hacemos como (x, y, z, W ), donde dos de estoscuádruplos representan el mismo punto si uno es un multiplicador distinto de cero del otro:no se permite el cuádruplo (0, 0, 0, 0). Como sucede en el espacio bidimensional, larepresentación estándar de un punto (x, y, z, W ) con W ≠ 
0 se indica (x/W, y/W, z/W, 1).
La transformación de un punto a esta forma se denomina homogeneización, igual queantes. Además los puntos cuya coordenada W es cero se llaman puntos en el infinito.También existe una interpretación geométrica. Cada punto en el espacio tridimensional serepresenta con una línea que pasa por el origen en el espacio de cuatro dimensiones, y lasrepresentaciones homogeneizadas de estos puntos forman un subespacio tridimensional deun espacio de cuatro dimensiones definido por la ecuación
W = 1.
 El sistema de coordenadas tridimensionales que se usará en los siguientes ejemplos esde mano derecha como se ilustra en la figura 2.16- Por convención las rotaciones positivasen el sistema de mano derecha son tales que, al ver hacia un eje positivo desde el origen,una rotación de 90˚ en sentido contrario al giro de las manecillas del reloj transformará uneje positivo en otro. 

Composición de transformaciones tridimensionales
En este apartado se analizará la forma de componer matrices de transformación tridimensionales usando un ejemplo. El objetivo es transformar los segmentos de línea dirigida P1 P2 y P1 P3 de su posición inicial en la parte (a) a su posición finalen la parte (b). De esta manera, el punto P1 se trasladará al origen P1 P2 quedará en el ejepositivo y P1 P3 quedará en la mitad del eje positivo del plano (x, y). Las longitudes de laslíneas no se verán afectadas por la transformación.Se presentan dos formas de lograr la transformación deseada. El primer método escomponer las transformaciones primitivas T,Rx, R y y Rz. Este método, aunque es algotedioso, es fácil de ilustrar y su comprensión nos ayudará en nuestro conocimiento de las transformaciones. El segundo método, que utiliza las propiedades de las matrices ortogonales especiales que se analiza en la sección anterior, se explica de manera mas breve pero es más abstracto.



jueves, 23 de febrero de 2012

Glosario 2da Unidad


TRANSFORMACIONES GEOMETRICAS

Coordenadas Geométricas:  son un instrumento usado para describir un punto en el espacio proyectivo.  Pueden usarse como un sistema alternativo de coordenadas para trabajar en el espacio euclídeo, pues éste puede verse como un subconjunto del espacio proyectivo. De ese modo, las coordenadas homogéneas son ampliamente usadas en infografía para la representación de escenas en tres dimensiones.

Stack: Es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Outúltimo en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.

martes, 21 de febrero de 2012

Cubo en 2D

CÓDIGO CUBO EN 2D (ahora de dos dimensiones realmente :S)


#include <glut.h>

void display(void) 
{        

typedef GLfloat point2[2];

point2 vertice[8] = {
{100.0,100.0},    //vector 0
{300.0,100.0},    //vector 1
{300.0,300.0},    //vector 2
{100.0,300.0},    //vector 3
{400.0,200.0},    //vector 4
{400.0,400.0},    //vector 5
{200.0,400.0},    //vector 6
{200.0,200.0}};   //vector 7

  glColor3f(1.0,0.0,0.0);
  gluOrtho2D(0.0, 500.0, 0.0, 500.0);
glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_LINES);

glVertex2fv(vertice[0]);
glVertex2fv(vertice[1]);

glVertex2fv(vertice[1]);
glVertex2fv(vertice[2]);

glVertex2fv(vertice[2]);
glVertex2fv(vertice[3]);

  glVertex2fv(vertice[3]);
  glVertex2fv(vertice[0]);

glVertex2fv(vertice[1]);
glVertex2fv(vertice[4]);

glVertex2fv(vertice[2]);
glVertex2fv(vertice[5]);

glVertex2fv(vertice[5]);
glVertex2fv(vertice[4]);

glVertex2fv(vertice[5]);
glVertex2fv(vertice[6]);

glVertex2fv(vertice[6]);
glVertex2fv(vertice[3]);

glVertex2fv(vertice[0]);
glVertex2fv(vertice[7]);

glVertex2fv(vertice[4]);
glVertex2fv(vertice[7]);

glVertex2fv(vertice[6]);
glVertex2fv(vertice[7]);

glEnd();
        glFlush();
}

void main(int argc, char** argv) 
{
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
        glutInitWindowSize(512, 512);
        glutCreateWindow("Cubo 2D");
        glutDisplayFunc(display);

        glutMainLoop();       
}


RESULTADOS



lunes, 20 de febrero de 2012

Graficacion en 2D

 
Algoritmo DDA para generación de líneas


Analizador Diferencial Digital (DDA) se usa para la interpolación lineal de veriables sobre un intervalo entre un punto de comienzo y un punto de fin. 
Los DDAs se usan para rastreo de lineas, triangulos y polígonos. En la implementación mas simple del algoritmo DDA interpola valores en intervalo [(xinicio, yinicio), (xfin, yfin)] por calculo para cada xi las equaciónes xi = xi−1+1, yi = yi−1 + Δy/Δx, donde Δx = xfin − xinicio y Δy = yfin − yinicio.


Para correr el ejemplos tienes que descargar la libreria de clases The tao framework de aqui, lo descomprimen y buscan en la carpeta lib el archivo llamado freeglut.dll, lo copian y lo pengan en widows\system. Hecho todo esto, crean un nuevo proyecto en c# de consola y agregan las referencias hacia los archivos Tao.FreeGlut.dll y Tao.OpenGl.dll que se encuentran en la carpeta que descomprimieron "taoframework-2.1.


Y después el código




static double x1, y1, x2, y2;  
main{
 Console.WriteLine("introduzca el valor de X1");
            x1 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca el valor de Y1");
            y1 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca el valor de X2");
            x2 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca el valor de Y2");
            y2 = Convert.ToDouble(Console.ReadLine());

            Glut.glutInit();//funciones propias de opengl
        Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
        Glut.glutInitWindowSize(640, 480);//creamos una ventana
        Glut.glutCreateWindow("**************Algoritmo DDA**************");//colocamos titulo a la ventana
           //llamamos a la funcion dda
        Glut.glutDisplayFunc(dda);
      Glut.glutMainLoop();  

}


 public static void dda()
        {
            //componentes necesarios de opengl
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);//limpia el buffer de la pantall
            Gl.glColor3f(0.6F, 0.6F, 0.6F);//poner color a los pixeles
            Gl.glLoadIdentity();//''muy importante;
            Gl.glPointSize(2.0f);//medida de los puntos
            Gl.glBegin(Gl.GL_POINTS);//funcion para dibujar puntos
            //dibujando el plano
            float z = -1, w = 1, c = 0;
            for (int i = 0; i < 200; i++)
            {
                Gl.glColor3f(w, c, z);
                Gl.glVertex2d(z, 0);
                Gl.glVertex2d(0, w);
                z += .01f;
                w -= .01f;
                c += .1f;
            }
            Gl.glEnd();//termina funcion para dibujar puntos
            ///pasamos las 
            Gl.glPointSize(5.0f);//sirve para el tamaño de los pixeles
            Gl.glColor3f(0.6f, 1.0f, 0.6f);//sirve para el color de los pixeles
            ddaDibujar(x1, y1, x2, y2);

        }



public static void ddaDibujar(double x1,double y1,double x2, double y2)
        {
            double xinicial = x1, yinicial = y1, xfinal = x2, yfinal = y2,x,y;
            double deltax, deltay, xincremento, yincremento;
            double pasos;
            deltax = xfinal - xinicial;
            deltay = yfinal - yinicial;
            if (Math.Abs(deltax) > Math.Abs(deltay))
                pasos = Math.Abs(deltax);
            else
                pasos = Math.Abs(deltay);
            xincremento = (deltax / pasos) / 10;
            yincremento = (deltay / pasos) / 10;
            x = xinicial;
            y = yinicial;
            Gl.glBegin(Gl.GL_POINTS);
            Gl.glVertex2d(x, y);//funcion que pinta un pixel en las coordenadas especificadas
            for (double k = .1; k <= pasos; k += .1)
            {
                x = (x + xincremento);
                y = (y + yincremento);
                Gl.glVertex2d(x, y);
            }
            Gl.glEnd();
            //termina dda
        }

Resultados


 


Algoritmo de Bresenham para trazar lineas
Este algorimo a diferencia del anterior sirve para trazar una linea entre dos puntos especificados en el codigo
Aqui se dara un ejemplo de como desarrollarlo en openGL
Basicamente lo que desarrolla es lo que el dibujo de abajo muestra
static double x1, y1, x2, y2;  


main{
           Console.WriteLine("introduzca el valor de X1");
            x1 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca el valor de Y1");
            y1 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca el valor de X2");
            x2 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca el valor de Y2");
            y2 = Convert.ToDouble(Console.ReadLine());

            //inicializar todo esto para tao opengl
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
            Glut.glutInitWindowSize(640, 480);
            Glut.glutCreateWindow("**************Bresenham**************");
            //termina inicializacion de componentes tao opengl
            Glut.glutDisplayFunc(Bresen);
            
            Glut.glutMainLoop();

}


public static void Bresen()
        {
            //componentes necesarios
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
            Gl.glColor3f(0.6F, 0.6F, 0.6F);
            Gl.glLoadIdentity();

            Gl.glBegin(Gl.GL_POINTS);
            //dibujando el plano
            float z = -1, w = 1, c = 0;
            for (int i = 0; i < 200; i++)
            {
                Gl.glColor3f(w, c, z);
                Gl.glVertex2d(z, 0);
                Gl.glVertex2d(0, w);
                z += .01f;
                w -= .01f;
                c += .1f;
            }
            Gl.glEnd();
            Gl.glPointSize(5.0f);
            Gl.glColor3f(1.0f, 0.111f, 1.0f);
            BresenDibujar(x1, y1, x2, y2);
        }



  public static void BresenDibujar(double x1,double y1,double x2,double y2)
        {
            double xinicial = x1, yinicial = y1, xfinal = x2, yfinal= y2, x=0, y=0;
            double deltax, deltay, constanteP,ultimo;
            deltax = Math.Abs( xfinal - xinicial);
            deltay =Math.Abs( yfinal - yinicial);
            constanteP = 2 * deltay - deltax;
            if (xinicial > xfinal)
            {
                x = xfinal;
                y = yfinal;
                ultimo = xinicial;
            }
            else
            {
                x = xinicial;
                y = yinicial;
                ultimo = xfinal;
            }
            Gl.glBegin(Gl.GL_POINTS);
            //Gl.glColor3f(1f, 1.0f, .5f);
            Gl.glVertex2d(x, y);
            while (x < ultimo)
            {
                x +=  .1;
                if (constanteP < 0)
                    constanteP +=2 * deltay;
                else
                {
                    y += .1;
                    constanteP += 2 * (deltay - deltax);
                }
                Gl.glVertex2d(x, y);
            }
            Gl.glEnd();
        }

Resultados


 




Algorimo para desarrollar circunferencias

Con este algorimto que se muestra a continuacion se desarrolla un circulo por medio de un algoritmo desarrollaodr por  Bresenham y se dira tambien como desarollar.
El algoritmo de línea de Bresenham se adapta a la generación de circunferencias al establecer los parámetros de decisión para identificar el pixel más cercano a la circunferencia en cada paso delmuestreo.Además sincroniza el dibujado de los píxeles en cada octante de la circunferencia.


static double x1, y1, x2, y2;

main{
 Console.WriteLine("introduzca x");
            xc = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca y");
            yc = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca r");
            r = Convert.ToDouble(Console.ReadLine());
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
            Glut.glutInitWindowSize(500, 500);
            Glut.glutCreateWindow("**************Circulo**************");
            Glut.glutDisplayFunc(circulo);

            Glut.glutMainLoop();
}

public static void circulo()
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
            Gl.glColor3f(0.6F, 0.6F, 0.6F);
            Gl.glLoadIdentity();
            Gl.glPointSize(5f);
            
            Gl.glBegin(Gl.GL_POINTS);
            
            float z = -1, w = 1, c = 0;
            for (int i = 0; i < 200; i++)
            {
                Gl.glColor3f(w, c, z);
                Gl.glVertex2d(z, 0);
                Gl.glVertex2d(0, w);
                z += .01f;
                w -= .01f;
                c += .1f;
            }
//mandar los puntos
            circuloAlgoritmo(xc, yc,r);
            Gl.glEnd();
        }



public static void circuloAlgoritmo(double xc, double yc, double r)
        {
            
            double x = 0;
            double y = r;
            double p = 0.1f - r;
            pintar(xc, yc, x, y);
            while (x < y)
            {
                x+=.1f;
                if (p < 0)
                    p += .2f * x + .1f;
                else 
                {
                    y-=.1f;
                    p += .2f * (x - y) + .1f;
                }
                pintar(xc, yc, x, y);
            }
        }



//Creamos el metodo pintar:
public static void pintar(double xc, double yc, double x, double y)
        {
            Gl.glColor3f(1f, .6f, 1f);
            Gl.glVertex2d(xc + x, yc + y);
            Gl.glVertex2d(xc - x, yc + y);
            Gl.glVertex2d(xc + x, yc - y);
            Gl.glVertex2d(xc - x, yc - y);
            Gl.glColor3d(0f, .6f, 1f);
            Gl.glVertex2d(xc + y, yc + x);
            Gl.glVertex2d(xc - y, yc + x);
            Gl.glVertex2d(xc + y, yc - x);
            Gl.glVertex2d(xc - y, yc - x);

}



Resultados
 
Referencias



http://opengl.blogspot.es/
http://dariatodoloqueseporloquenose.blogspot.com/2008/12/algoritmos-open-gl-para-generacin-de.html