Issuu on Google+

S.E.P.

D.G.E.S.T.

D.I.T.D.

INSTITUTO TECNOLÓGICO SUPERIOR DE LIBRES Organismo Público Descentralizado del Gobierno del Estado de Puebla

INGENIERÍA EN SISTEMAS COMPUTACIONALES

“EJECUCIÓN DEL ALGORITMO DDA”

PRESENTA:

CRUZ LIMÓN EVA ITZEL ROMERO AGUILLAR SALVADOR

LIBRES, PUEBLA, FEBRERO 2012


Algoritmo DDA

El algoritmo de análisis diferencial digital (DDA, digtal differential analizer) es un algoritmo de digitalización de líneas basado en calcular dy, dx utilizando la ecuación; ecuación 1 O la ecuación: ecuación 2 Las líneas se muestrean a intervalos unitarios según una de las coordenadas y los correspondientes valores enteros más próximos al trayecto lineal se calculan para la otra coordenada. Es un método para el cálculo de posiciones de implementar la ecuación:

pixeles más rápido que

ecuación 3 Se elimina la multiplicación de la ecuación 3 haciendo uso de las propias características del proceso de digitalización, aplicándose los incrementos apropiados en las direcciones x ó y para pasar de una posición de pixel a la siguiente a lo largo de la línea. Sin embargo, la acumulación de errores de redondeo en las sucesivas sumas del incremento de coma flotante pueden hacer que las posiciones de píxel sufran cierta deriva con respecto al verdadero trayecto lineal, para segmentos lineales largos.

2


Trazado de la línea simple (herramientas) Para trazar una línea simple mediante el algoritmo DDA se implementará dicho algoritmo indicando en el las cuatro variables indicadas con valores que asigne el usuario. Las herramientas a utilizar serán: - Microsoft Visual Studio 2008 -Tao Framework 2.1.0

Para comenzar se creará un nuevo proyecto en consola, con el lenguaje de programación C#. Una vez que se tiene el código escrito en editor se prosigue para hacer referencia a dos archivos del Framework Tao 2.1.0, identificadas con el nombre Tao.FreeGlut.dll y Tao.OpenGl.dl(estos archivos se encuentran comprimidos dentro de la carpeta “taoframework-2.1.0-bin”). Existe un archivo mas que será de necesario para la ejecución del programa de trazado de la línea, este se identifica con el nombre “freeglut.dll” se encuentra dentro de la carpeta “lib” este archivo tendrá que ser copiado a la carpeta widows\system.

Trazado de la línea simple (procedimiento) 1.-se declara como variables globales para poder pedir al usuario los puntos a graficar static double x1, y1, x2, y2;

2.-en la función main se escribe el siguiente código 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();

3


3.- creación la funcion llamada dda de tipo static y se agrega el siguiente código 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); }

4.-definición de la función ddaDibujar que implementará el código del algoritmo DDA 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 }

4


Trazado de la línea simple (resultados) Los valores de las coordenadas con los cuales se hiso prueba del programa fueron (x1=0, y1=0, x2=0, y2=0). Figura 1.

Figura 1. Datos de prueba para las variables

Los resultados obtenidos gráficamente en el plano x,y se muestran a continuación. Figura 2.

Figura 2 Resultado Gráfico del algoritmo DDA.

5


Trazado de la línea con aumento de grosor (procedimiento) Para aumentar el grosor en una línea se implementa en el código de la función ddaDibujar, una serie de instrucciones según el tamaño de grosor, a las cuales se dará un aumento de .02 para cada coordenada en el eje x. teniendo de la siguiente manera el código en la función ddaDibujar. 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+.02, y); Gl.glVertex2d(x + .04, y); Gl.glVertex2d(x + .06, y); Gl.glVertex2d(x + .8, y); Gl.glVertex2d(x + .8, y); } Gl.glEnd(); //termina dda }

6

Código implementado para aumentar el grosor de la línea


Trazado de la línea con aumento de grosor (resultados) Los valores de las coordenadas con los cuales se hiso prueba del programa fueron (x1=0.01, y1=0.01, x2=0.98, y2=0.98). Figura 3.

Figura 3. Datos de prueba para las variables

Los resultados obtenidos gráficamente en el plano x,y se muestran a continuación. Figura 4.

Figura 4 Resultado Gráfico del algoritmo DDA aumentando el grosor.

7


Trazado de la línea punteada (procedimiento) Para dibujar una línea punteada se implementa en el código de la función ddaDibujar, una serie de instrucciones la cual contendrá un condicional el cual a cada imprimirá coordenadas en eje “x” y al siguiente no lo imprimirá y continuando así respectivamente.

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); double nx; nx = x * 10; if (nx % 2 == 0) { Código implementado para Gl.glVertex2d(x + .02, y); el trazo de la línea punteada Gl.glVertex2d(x + .04, y); Gl.glVertex2d(x + .06, y); Gl.glVertex2d(x + .08, y); Gl.glVertex2d(x + .1, y); } } Gl.glEnd(); //termina dda }

8


Trazado de la línea punteada (resultados)

Los valores de las coordenadas con los cuales se hiso prueba del programa fueron (x1=0, y1=0, x2=0, y2=0). Figura 5.

Figura 5. Datos de prueba para las variables

Los resultados obtenidos gráficamente en el plano x,y se muestran a continuación. Figura 6.

Figura 6 Resultado Gráfico del algoritmo DDA de la línea punteada. 9


Referencia bibliográfica 

GRAFICOS POR COMPUTADORA CON OPENGL

DONALD HEARN; M. PAULINE BAKER PEARSON EDUCATION 3ra EDICIÓN  OPENGL: CSGL Y THE TAO FRAMEWORK EN CSHARP. AUTOR: ING. JESÚS HERNÁNDEZ LEÓN. DOCENTE DEL INSTITUTO TECNOLÓGICO SUPERIOR DE LIBRES. REVISADO EN: HTTP://OPENGL.BLOGSPOT.ES/

10


Ejecución del algoritmo DDA