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 [(x_inicio, y_inicio), (x_fin, y_fin)] por calculo para cada x_i las equaciónes x_i = x_i−1+1, y_i = y_i−1 + Δy/Δx, donde Δx = x_fin − x_inicio y Δy = y_fin − y_inicio.


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://es.wikipedia.org/wiki/Analizador_Diferencial_Digital_(algoritmo_gr%C3%A1fico)

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