Universidad Simn Bolvar Computacin grfica I Sep Dic 2011

Algoritmos para dibujo de lneas

Realizado por:

Natalya Blanco Rubn Arvalo

Contenido

Lneas Algoritmo DDA Algoritmo Breseham Algoritmo Xiaolin Wu o Antialiasing

Lneas

La Recta es una sucesin infinita o continua de puntos alineados en una sola direccin. Es una de las primitivas bsicas en Computacin Grfica Viene dada por la ecuacin Y=mX+b , donde m es la pendiente de la recta y b es el corte con el eje Y.
B

A Figura 1

Lneas

Para dibujar la recta hay que hallar todos los puntos medios entre el inicial y el final. El problema es que la ubicacin de cada pixel se representa con un entero y las posiciones halladas mediante la ecuacin son valores reales. Por lo tanto, se necesitan formas eficientes de dibujar la recta lo ms parecida posible a la realidad, a pesar de las limitaciones que las pantallas de pxeles nos pongan.

Transformar primitivas en pixeles

Las coordenadas de los pxeles deben estar lo ms cerca posible de una lnea recta real Un algoritmo debe cumplir con:

La secuencia de pxeles debe ser lo ms recta que se pueda. Las lneas deben tener el mismo grosor e intensidad sin importar el grado de inclinacin Las lneas deben dibujarse lo ms rpido posible

Transformar lnea a pixel

Figura 2 Tomada de www2.dis.ulpgc.es/~ii-fgc/Tema%202%20-%20Primitivas%202D.pdf

Algoritmo Ineficiente
Algoritmo: Se calcula m (pendiente) Calculo de b (pto de corte en el eje Y) Para x=x0 hasta x=xn y = mx + b Dibujar pixel (x,redondear(y))

Se necesita una multiplicacin flotante, una suma y un redondeo por cada paso

Analizador diferencial digital

Algoritmo DDA
Busca determinar los valores enteros correspondientes ms prximos a la trayectoria de la lnea para la otra coordenada. Para una pendiente positiva, |m| 1, se realiza el muestreo de x en intervalos y se calcula el valor sucesivo de y con la siguiente ecuacin: Yk+1 = Yk +m El subndice k crece con razn 1 hasta alcanzar el valor final, y m toma valores entre 0 y 1 reales, los valores de y calculados deben ser redondeados. Si la pendiente es negativa, se utiliza un caso anlogo con la siguiente ecuacin: Xk+1 = Xk + 1/m

Algoritmo DDA
Pseudo Cdigo
Funcin DDA_Line (int X0, y0, x1, y1) Dx = x1 - x0 Dy = y1 y0 Si |Dx| > |Dy| entonces pasos = |Dx| Si no pasos = |Dy| xinc = Dx / pasos yinc = Dy / pasos x = x0 y = y0 Dibujar Pixel (redondear(x), redondear(y)) Para k=1 hasta k = pasos x = x + xinc y = y + yinc Dibujar Pixel (redondear(x), redondear(y))

Problemas DDA

Presenta errores de acumulacin Redondeo lento

Mejora Separar los incrementos m y 1/m en parte entera y fraccionaria, para reducir a operaciones de enteros

Cdigo DDA - JAVA

void Line(Display* display, Window win, GC gc, int x0, int y0, int x1, int y1){ float x, y, xs, ys; int dx, dy, steps; dx = x1 x0; dy = y1 y0; x = x0; y = y0; if (abs(dx) > abs(dy)) steps = abs(dx); else steps = abs(dy); if (steps == 0) { XdrawPoint(display,win,gc,round(x),round(y)); fprintf(stderr,this line is a point); Return; } xs = dx/steps; ys = dy/steps; for (i = 0; i <= steps; i++){ XdrawPoint(display,win,gc,round(x),round(y)); x = x + xs; y = y + ys; } }
Tomado de: Alfredo Weitzenfeld Grfica la Lnea. Recuperado de http://www.docstoc.com/docs/273281/Graficos-Lineas-Circulos?term=linea-algoritmo-completo-bresenham#

Algoritmo Breseham
Calcula cul de dos pxeles es el ms cercano a la trayectoria de una lnea. El pixel (Xk, Yk) se divide en (Xk+1, Yk) y (Xk+1, Yk+1) y hay que decidir cul pintar, cualculando la distancia vertical entre el centro de cada pixel y la lnea real.

Figura 3 Tomada de www2.dis.ulpgc.es/~ii-fgc/Tema%202%20-%20Primitivas%202D.pdf

Algoritmo Bresenham
Pseudo Cdigo
Funcin Bresenham (int X0, y0, x1, y1) // para el caso 0 < m < 1, siendo x0 < x1 Dibujar Pixel (x0, y0) Calculamos: A=2y B=2y-2x Obtener el valor para p0 = 2y-x Para cada Xk sobre la lnea si pk < 0 Dibujar Pixel (xk+1, yk) pk+1 = pk + A si pk > 0 Dibujar Pixel (xk+1, yk+1) pk+1 = pk + B
Si m > 1: intercambiamos x e y Si m < 0: el cambio es similar

Cdigo Bresenham
public void Bresenham(Graphics g,int x0, int y0, int x1, int y1) int x, y, dx, dy, p, incE, incNE, sx, sy; dx = (x1 - x0); dy = (y1 - y0); /* Se determina el punto para comenzar, y para terminar */ if (dy < 0) { dy = -dy; Sy = -1; } else sy = 1; if (dx < 0) { dx = -dx; Sx = -1; } else sx = 1; x = x0; y = y0; g.drawLine( x0, y0, x0, y0);

Cdigo Bresenham Cont.

/* se itera hasta el final de la lnea */ if(dx>dy){ p = 2*dy - dx; incE = 2*dy; incNE = 2*(dy-dx); while (x != x1){ x = x + sx; if (p < 0){ p = p + incE; } else { y = y + sy; p = p + incNE; } g.drawLine( x0, y0, x0, y0); } }else{ p = 2*dx - dy; incE = 2*dx; incNE = 2*(dx-dy); while (y != y1){ y = y + sy; if (p < 0){ p = p + incE; } else { x = x + sx; p = p + incNE; } g.drawLine( x0, y0, x0, y0); }}}

Anti-Aliasing
Aliasing es la apariencia de escaleras o escalones que se forman debido a la discretizacin de lo pxeles. Propuesta Hardware: - Mayor resolucin - Pxeles ms pequeos

Figura 4 tomada de www.cimat.mx/~cesteves/cursos/cg/pdf/Antialiasing.pdf

Algoritmo Xiaolin Wu
Mejora del algoritmo de Bresenham, para dibujar rectas en dispositivos de grficos rasterizados de manera que se reduzca el aliasing. Esta basado en dibujar parejas de pxeles a lo largo del trazado de la lnea con diferentes intensidades, en funcin de la a la recta real.

Pseudo cdigo Xiaolin Wu

funcin plot(x, y, c) es Dibujar el pixel en (x, y) con brillo c (donde 0 c 1) funcin ipart(x) es Retornar parte entera de x funcin redondear(x) es Retornar ipart(x + 0.5) funcin fpart(x) es Retorna parte fraccional de x funcin rfpart(x) es Retorna 1 - fpart(x)

Pseudo cdigo (Cont.)

funcin dibujarLinea(x1,y1,x2,y2) es dx = x2 - x1 dy = y2 - y1 Si abs(dx) < abs(dy) entonces intercambiar x1, y1 intercambiar x2, y2 intercambiar dx, dy Si x2 < x1 intercambiar x1, x2 intercambiar y1, y2 gradiente = dy / dx xend = redondear(x1) yend = y1 + gradiente * (xend - x1) xgap = rfpart(x1 + 0.5) xpxl1 = xend ypxl1 = ipart(yend) dibujar(xpxl1, ypxl1, rfpart(yend) * xgap) dibujar(xpxl1, ypxl1 + 1, fpart(yend) * xgap) intery = yend + gradiente

Pseudo cdigo (Cont.)

xend = redondear(x2) yend = y2 + gradiente * (xend - x2) xgap = fpart(x2 + 0.5) xpxl2 = xend ypxl2 = ipart (yend) dibujar (xpxl2, ypxl2, rfpart (yend) * xgap) dibujar(xpxl2, ypxl2 + 1, fpart (yend) * xgap) // ciclo principal for x from xpxl1 + 1 to xpxl2 - 1 do dibujar(x, ipart (intery), rfpart (intery)) dibujar(x, ipart (intery) + 1, fpart (intery)) intery = intery + gradiente fin

Referencias

Tema 2 - Primitivas 2D. Recuperado Noviembre 8, 2011 de www2.dis.ulpgc.es/~ii-fgc/Tema%202%20-%20Primitivas%202D.pdf Algoritmo DDA Analizador Diferencial Digital. Recuperado Noviembre 8, 2011 de http://maiki69.tripod.com/DDA.htm Rosetta Code - Xiaolin Wu's Line Algorithm . Recuperado Noviembre 8, 2011 de http://rosettacode.org/wiki/Xiaolin_Wu%27s_line_algorithm Medelln Anaya, Hctor E. Algoritmo basado en la ecuacin de la recta. Recuperado Noviembre 8, 2011 de http://galia.fc.uaslp.mx/~medellin/Applets/LineasRectas/Recta.htm Algoritmo DDA . Recuperado Noviembre 8, 2011 http://sites.google.com/site/proyectosroboticos/algoritmo-dda de

Gmez, Francisco (Febrero 16, 2011) - Una breve introduccin a Antialiasing. Recuperado Noviembre 8, 2011 de www.cimat.mx/~cesteves/cursos/cg/pdf/Antialiasing.pdf