Los algoritmos rasterizan (asignan intensidad a pixeles) para dibujar primitivas gráficas como líneas y polígonos. El algoritmo de Bresenham es un método incremental preciso que usa solo aritmética entera para dibujar líneas, minimizando el error. Evalúa un parámetro entero para determinar el próximo pixel a trazar a lo largo de la línea. El algoritmo de llenado por inundación ("flood fill") pinta un área interior reemplazando píxeles de un color interior específico con un color de re

1. Algoritmos Raster
Objetivos: Rasterizar (asignar intensidad a pixeles) para dibujar / pintar primitivas
gráficas
• líneas
• polígonos
• círculos, etc Incluye algoritmos de clipping
Algoritmos raster para dibujar líneas
1. Algoritmo incremental (método de diferencias similar a métodos para EDP)
• Aritmética entera
y = mx + B pendiente m =
Supuesto: |m| ≤ 1
Se avanza de izquierda a derecha
Observaciones
• x, y definidos en función de valores previos en el paso anterior
• No se necesita calcular intersección en y
• No se ocupan multiplicaciones
• Si |m| > 1, invertir roles de x e y (paso unitario en y e incremento de y en 1/m)
• Se puede generalizar a aritmética de punto flotante

2. Algoritmo Básico
procedure Line( {Asuma -1 ≤ m ≤ 1, x0 > x1}
x0, y0 {Punto izquierdo}
x1, y1, {Punto derecho}
value: integer); {Valor a poner en los pixeles de la línea}
var
x : integer; {x varía entre x0 y x1 en incrementos unitarios}
dy, dx, y, m : real;
begin
dy :=y1 - y0;
dx :=x1 - x0;
m :=dy|dx;
y :=y0;
for x := x0 to x1 do
begin
WritePixel (x, Round(y), value); {Asigne value al pixel}
y := y + m {Incremente y en la pendiente m}
end
end;
Desventajas del algoritmo incremental básico
• La función Round toma mucho tiempo
• y, m son reales

3. Algoritmo de Bresenham
- Bresenham desarrolló un algoritmo incremental clásico que usa solo aritmética
entera evitando la función Round
- La técnica se generaliza al dibujo de círculos
- Bresenham demostró que sus algoritmos generan las aproximaciones que
minimizan el error (distancia)
Algoritmo de Bresenham (variación)
procedure MidpointLine (x0, y0, x1, y1, value: integer);
var
dx, dy, incrE, incrNE, d, x, y : integer;
begin
dx := x1 - x0;
dy := y1 - y0;
d := 2 * dy -dx; {valor inicial para d}
incrE := 2 * dy; {Incremento usado para moverse a E}
incrNE := 2 * (dy - dx); {Incremento usado para moverse a NE}
x := x0;
y := y0;
WritePixel (x, y, value); {Pixel de partida}
while x < x1 do
begin
if d <= 0 then
begin {Elija NE}
d := d + incrE;

4. x := x + 1
end
else
begin {Elija NE}
d := d + incrNE;
x := x + 1
y := y + 1
end;
WritePixel (x, y, value) {Elige pixel más cercano a la línea}
end{while}
end;
Observaciones:
• Para eliminar la fracción se redefine (no afecta el signo)
• El algoritmo trabaja solo para 0 <m < 1 Otras pendientes se manejan por
reflexiones con respecto a ejes del sistema de coordenadas.
• No se han considerado casos particulares líneas verticales y horizontales de
pendientes ± 1
Obs:
Distinto grosor dependiendo de la pendiente ¿Cómo tratarlo?
• Variación de la intensidad en función de la pendiente
• Tratando la línea como rectángulo

5. Algoritmos de Punto medio: Bresenham
Un algoritmo preciso y efectivo para la generación de líneas de rastreo,
desarrollado por Bresenham, convierte mediante rastreo las líneas al utilizar sólo
cálculos incrementales con enteros que se pueden adoptar para desplegar
circunferencias y otras curvas.
El algoritmo de línea de Bresenham se basa en probar el signo de un parámetro
entero, cuyo valor es proporcional a la diferencia entre las separaciones de las dos
posiciones de pixel de la trayectoria real de la línea.
Para realizar el trazo de línea de Bresenham para una línea con una pendiente
positiva menor que 1 se deben seguir los siguientes pasos:
1.Se capturan los dos extremos de la línea y se almacena el extremo izquierdo en
(x0 , y0).
2.Se carga (x0 , y0)en el búfer de estructura; es decir, se traza el primer punto.
3.Se calculan las constantes Δx , Δy, 2Δy y 2Δy-2Δx y se obtiene el valor inicial
para el parámetro de decisión como p0 = 2Δy - Δx.
4.En cada xk,a lo largo de la línea, que inicia en k=0, se efectúa 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 que se debe trazar es (xk +1, yk+1)
y pk +1 = pk + 2Δy - 2Δx
5.Se repite el paso 4 Δx veces.
Algoritmo de Flood Fill
En muchas ocasiones se desea llenar un área que no se define dentro de una
frontera de un solo color. Es posible pintar esa área al sustituir un color interior
específico, en lugar de buscar un valor del color de la frontera. Este planteamiento
se denomina algoritmo de llenado con flujo o Flood Fill.
El algoritmo consiste seleccionar un punto interior específico (x, y) y
posteriormente se vuelven a establecer los valores de pixel que ahora se definen
en un color interior determinado con el color de llenado que se desea. Si el área
que se quiere pintar tiene más de un color interior, primero se vuelve a establecer
los valores de pixel, de modo que todos los puntos interiores tengan el mismo
color. Si se utiliza ya sea el planteamiento de las 4 regiones conectadas o de las 8

6. regiones conectadas, se pasa por las posiciones de pixel hasta que se repinten
todos los puntos interiores.