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

“ALGORITMO DDA”

TRABAJO DE INVESTIGACIÓN

PRESENTA:

BAUTISTA RAMOS NAZARIO HERRERA GONZALEZ CARLOS ARTURO

LIBRES, PUEBLA, FEBRERO 2012

1. Definir el algoritmo DD

ALGORITMO DDA

El algoritmo DDA de análisis diferencial digital es un algoritmo de utilización de líneas

basado en calcular Sy o Sx. Las líneas se muestrean a intervalos unitarios según una de las

coordenadas y los correspondientes valores enteros mas próximos al trayecto lineal se

calculan para la otra coordenada [1].

Vamos a considerar primero una línea con pendiente positiva. Si la pendiente es

menor o igual a 1, mostraremos a intervalos unitarios según el eje de las X y calculamos

los valores sucesivos de Y [1].

El subíndice que adopta valores enteros comenzando en 0 para el primer punto e

incrementándose en una unidad cada vez hasta que se alcanza el extremo de la línea.

Puesto que puede ser cualquier numero real entre 0.0 y 1.0 cada valor calculado de y

debe redondearse al entero más próximo, lo que nos dará la posición de un pixel de

pantalla en la columna x que estemos procesando. [1]

Para las líneas con una pendiente positiva superior a 1.5 invertimos los papeles x

e>/ es decir, muestreamos a intervalos de y {8y =1} y calculamos los valores de X

consecutivos. [1]

En este caso, cada valor de x calculado se redondea a la posición de pixel más

cercana en la línea de exploración Y actual. [1]

CODIFICACIÓN

# i n c l u d e < s t d l i b . h> ^ i n c l u d e <math.h> i n l i n e i n t round ( c o n s t f l o a t a) { r e t u r n i n t (a + 0 . 5 ) ; ) v o i d lineDDA ( i n t xO, int yO, i n t xEnd, int yEnd) i n t dx = xEnd • xO, dy • yEnd - yO, s t e p s , k; f l o a t x l n c r e m e n t , y l n c r e m e n t , x » xO, y • yO; i f {fabs (dx) > fabs (dy) ) s t e p s = fabs ( d x ); e l s e s t e p s = fabs '(dy) ; x l n c r e m e n t * f l o a t (dx) / f l o a t ( s t e p s );

y l n c r e m e n t * f l o a t (dy) / f l o a t ( s t e p s ); s e t P i x e l (round (x) , round ( y ) ); f o r <k - 0; k < s t e p s ; k++) { x +• x l n c r e m e n t; y +- y-Increment; s e t P i x e l (round ( x ) , round ( y ) ); [1]

2.- Modificaciones correspondientes para el trazo de líneas de

los siguientes tipos

a. Aumento del grosor

b. Línea punteada

1. Insercion de los valores de x1, y1, x2, y2 respectivamente

Resultado de la insercion normal

2. Código para generar una línea mas gruesa

public static void ddaDibujar(double x1, double y1, double x2, double y2)

{

//empieza dda

double xinicial = x1, yinicial = y1, xfinal = x2, yfinal =

y2, x, y,z,w;

double deltax, deltay, xincremento, yincremento;

double pasos;

deltax = xfinal - xinicial;// delta x =x2-x1

deltay = yfinal - yinicial;// delta y =y2-y1

if (Math.Abs(deltax) > Math.Abs(deltay))

pasos = Math.Abs(deltax);

else

pasos = Math.Abs(deltay);

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

z = xinicial;

w = yinicial;

Gl.glBegin(Gl.GL_POINTS);

//Gl.glColor3f(1f, 1.0f, .5f);

Gl.glVertex2d(x, y);

//Gl.glVertex2d(x+1, y);

//Gl.glVertex2d(x + 2, y);

{

for (double k = .1; k <= pasos; k += .1)

{

x = (x + xincremento);

y = (y + yincremento);

z = (z + xincremento);

w = (w + yincremento);

Gl.glVertex2d(x, y);

Gl.glVertex2d(z, w+.014);//se incrementa por parte de

el eje y, ya que el eje

//x es constante en su

posicion

// Gl.glVertex2d(x+1, y);

//Gl.glVertex2d(x + 2, y);

}

}

Por medio de un incremento en el eje “y” de 0.014 se obtienen 2 líneas tan juntas

que se logra aumentar el grosor de la línea generada

2.2 Inserción de datos

2.3 Incremento en la segunda línea con respecto a y de valor = 0.014

3. Código para una línea más junta punteada

public static void ddaDibujar(double x1, double y1, double x2, double y2)

{

//empieza dda

double xinicial = x1, yinicial = y1, xfinal = x2, yfinal =

y2, x, y,z,w;

double deltax, deltay, xincremento, yincremento;

double pasos;

deltax = xfinal - xinicial;// delta x =x2-x1

deltay = yfinal - yinicial;// delta y =y2-y1

if (Math.Abs(deltax) > Math.Abs(deltay))

pasos = Math.Abs(deltax);

else

pasos = Math.Abs(deltay);

//if (Math.Abs(deltax) = Math.Abs(deltay))

// pasos = Math.Abs(deltax);

//else

// pasos = Math.Abs(deltay);

xincremento = ((deltax / pasos) / 50);

yincremento = (deltay / pasos) / 50;

x = xinicial;

y = yinicial;

z = xinicial;

w = yinicial;

Gl.glBegin(Gl.GL_POINTS);

//Gl.glColor3f(1f, 1.0f, .5f);

Gl.glVertex2d(x, y);

//Gl.glVertex2d(x+1, y);

//Gl.glVertex2d(x + 2, y);

{

for (double k = .1; k <= pasos; k += .1)

{

x = (x + xincremento);

y = (y + yincremento);

z = (z+ xincremento);

w = (w + yincremento);

Gl.glVertex2d(x, y);

Gl.glVertex2d(z, w);//se incrementa por parte de el

eje y, ya que el eje

//x es constante en su

posicion

// Gl.glVertex2d(x+1, y);

//Gl.glVertex2d(x + 2, y);

}

}

3.3 Captura en pantalla de la línea mas punteada

4. Código línea menos punteada 5. public static void ddaDibujar(double x1, double y1, double x2,

double y2)

6. { 7. //empieza dda 8. double xinicial = x1, yinicial = y1, xfinal = x2,

yfinal = y2, x, y,z,w;

9. double deltax, deltay, xincremento, yincremento; 10. double pasos;

11. deltax = xfinal - xinicial;// delta x =x2-x1

12. deltay = yfinal - yinicial;// delta y =y2-y1

13. if (Math.Abs(deltax) > Math.Abs(deltay))

14. pasos = Math.Abs(deltax);

15. else

16. pasos = Math.Abs(deltay);

17. //if (Math.Abs(deltax) = Math.Abs(deltay))

18. // pasos = Math.Abs(deltax);

19. //else

20. // pasos = Math.Abs(deltay);

21. xincremento = ((deltax / pasos) / 20);

22. yincremento = (deltay / pasos) / 20;

23. x = xinicial;

24. y = yinicial;

25. z = xinicial;

26. w = yinicial;

27.

28. Gl.glBegin(Gl.GL_POINTS);

29. //Gl.glColor3f(1f, 1.0f, .5f);

30. Gl.glVertex2d(x, y);

31. //Gl.glVertex2d(x+1, y);

32. //Gl.glVertex2d(x + 2, y);

33. {

34. for (double k = .1; k <= pasos; k += .1)

35. {

36. x = (x + xincremento);

37. y = (y + yincremento);

38. z = (z+ xincremento);

39. w = (w + yincremento);

40. Gl.glVertex2d(x, y);

41. Gl.glVertex2d(z, w);//se incrementa por

parte de el eje y, ya que el eje

42. //x es

constante en su posicion

43. // Gl.glVertex2d(x+1, y);

44. //Gl.glVertex2d(x + 2, y);

45. }

46.

}

4.1 Captura de la línea menos punteada

REFERENCIAS BIBLIOGRAFICAS.

1. - Gráficos por computadora con opengl, tercera edición, Donald Hearn M.

Pauline Baker. Paginas 95 y 94.