Algoritmo DDA (Analizador Diferencial Digital)

DDA: El Algoritmo DDA es un algoritmo de lnea de conversin de rastreo que se basa en el

clculo ya sea en el incremento de X o en el incremento de Y. La finalidad de este algoritmo es
determinar los valores enteros correspondientes ms prximos a la trayectoria de la lnea para
la otra coordenada.

Una implementacin de hardware o software de un Analizador Diferencial Digital (DDA) se usa

para la interpolacin lineal de variables sobre un intervalo entre un punto de comienzo y un
punto de fin.

El DDA se usan para rastreo de lneas, tringulos y polgonos. En la implementacin ms

simple del algoritmo DDA interpola valores en intervalo [(Xinicio, Yinicio), (Xfin, Yfin)] por
clculo para cada xi las ecuaciones xi = xi1+1, yi = yi1 + y/x,

Dnde: x = Xfin xinicio

y = Yfin yinicio.

ALGORITMO:

#include <stdlib.h>
#include <math.h>
inline int round (const float a) { return int (a + 0.5); }

void lineDDA (int x0, int y0, int xEnd, int yEnd) {
int dx = xEnd - x0, dy = yEnd - y0, steps, k;
float xIncrement, yIncrement, x = x0, y = y0;
if (fabs (dx) > fabs (dy))
steps = fabs (dx);
else
steps = fabs (dy);
xIncrement = float (dx) / float (steps);
yIncrement = float (dy) / float (steps);
setPixel (round (x), round (y));
for (k = 0; k < steps; k++) {
x += xIncrement;
y += yIncrement;
setPixel (round (x), round (y));
}
}
Algoritmo de Bresenham

El algoritmo de Bresenham se generaliza para lneas con una pendiente arbitraria al considerar
la simetra entre los diversos octantes y cuadrantes del plano de X Y.
Para una lnea con una pendiente m > 1, intercambiamos las funciones de las direcciones de X
y Y, pasamos a lo largo de Y en pasos unitarios y calculamos los valores sucesivos de X que se
aproximan ms a la trayectoria de la lnea. Asimismo, podemos revisar el programa para trazar
pxeles iniciando desde cualquier extremo.

Si se inicia desde el extremo izquierdo (x0, y0) de una lnea determinada, se pasa a cada
columna sucesiva y se traza el pixel cuyo valor de y se aproxima ms a la trayectoria de la lnea
de rastreo. Si suponemos que se debe desplegar el pixel en (xk, yk), a continuacin se necesita
decidir que pixel se debe desplegar en la columna xk+1. Las alternativas son los pixeles (xk+1,
yk), y (xk+1,yk+1).

Los pasos son:

1. Se capturan los dos extremos de la lnea y se almacena el extremo izquierdo en

(x0,y0). Al

2. Se carga (x0,y0) en el bufer de estructura, o sea, se traza el primer punto.

3. Se calculan las constantes y, x, 2 y, 2 y-2 x, y se obtiene el valor inicial para el

parmetro de decisin como p0 = 2 y - x.

4. En cada xk a lo largo de la lnea, que inicia en k = 0, se efecta la prueba siguiente: si

pk < 0, el siguiente punto que se debe trazar es (xk+1,yk) y pk +1 = pk + 2 y. De otro
modo, el siguiente punto en trazarse es (xk+1,yk+1) y pk +1 = pk + 2 y - 2 x.

5. Se repite el paso 4 otras x veces.

EJEMPLO:

Para ilustrar el algoritmo, utilicemos la lnea con extremos (20,10) y (30,18).

Esta lnea tiene una pendiente de 0.8, con x = 10, y = 8

El parmetro de decisin inicial tiene el valor p0 = 2 y - x = 6 y los incrementos para calcular

parmetros de decisin sucesivos son 2y = 16, 2y - 2x = -4

Trazamos el punto inicial (x0,y0) = (20,10) y determinamos las posiciones de pixel sucesivos a
lo largo de la trayectoria de la lnea a partir del parmetro de decisin como:
ALGORITMO :

#include <stdlib.h>
#include <math.h>

void lineBres (int x0, int y0, int xEnd, int yEnd) {
int dx = fabs (xEnd - x0), dy = fabs(yEnd - y0);
int p = 2 * dy - dx;
int twoDy = 2 * dy, twoDyMinusDx = 2 * (dy - dx);
int x, y;

/* Determinar qu extremo usar como posicin inicial. */

if (x0 > xEnd) {
x = xEnd;
y = yEnd;
xEnd = x0;
}
else {
x = x0;
y = y0;
}
setPixel (x, y);
while (x < xEnd) {
x++;
if (p < 0)
p += twoDy;
else {
y++;
p += twoDyMinusDx;
}
setPixel (x, y);
}
}