Facultad de Ingeniería – UNJBG E.P.

Ingeniería en Informática y Sistemas

Primitivas de Despliegue
La imágenes generadas por el computador se generan usando objetos gráficos primitivos, como
son puntos, rectas y círculos así como operaciones gráficas en pantalla, como ―borrar la
pantalla‖ o ―colocar la imagen‖ en parte de la pantalla.

i. Graficación de puntos y líneas: Tanto la memoria de imagen como la pantalla de barrido,

cuentan con un sistema de coordenadas bidimensionales, con el origen en la esquina
inferior izquierda, aunque este punto de origen puede variar ubicándose en la esquina
superior izquierda.. Se accede a cada pixel por un par de coordenadas (x,y) entero no
negativo.
Ninguno de los valores de las coordenadas de x o y deben exceder los límites del
dispositivo de presentación, de lo contrario puede producir un efecto de embrollamiento.
En estos casos se deben emplear técnicas de recorte que se estudiará más adelante.
Para graficar un punto en la pantalla debemos crear un procedimiento de graficación de
puntos:
dibujarpunto(x,y)

este procedimiento debe encender el pixel ubicado en la posición (x,y) de pantalla

(memoria de imagen). Los parámetros x e y deben ser constantes enteras.

ii. Trazado de rectas.

Al encender una cadena de pixeles adyacentes, un segmento aparece desplegado. Para
dibujar una recta, es necesario determinar cuáles pixeles se hallan cerca de ésta y
proporcionan la mejor aproximación a la recta deseada.

y y

0 x
0 x

Pág. 1
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

Líneas horizontales, Líneas de mayor dificultad de

verticales y rectas de graficación
45ª

a) Trazado de rectas horizontales y verticales

Son las más fáciles de dibujar, junto a las diagonales.
Las coordenadas en pantalla de los puntos de una recta horizontal se obtienen manteniendo
constante el calor de y e incrementando continuamente el valor de x en una unidad.
El siguiente procedimiento dibuja una línea horizontal desde (xinicial , y) hasta (xfinal , y),
xinicial  xfinal).

/* Dibuja una recta horizontal */

for(x=xinicial;x<=xfinal;x++)
dibujarpunto(x,y);

Si xinicial > xfinal, entonces de debe trabajar con x—en la estructura for.

Para trazar rectas verticales, el valor de x permanece fijo y el valor de y varía.

b) Rectas diagonales
Para trazar una recta diagonal con pendiente 1, se debe incrementar sucesivamente en una
unidad los valores de x e y, partiendo del inicio hasta llegar al extremo final de la recta. Todo
ello siempre que el formato de imagen sea igual a 1.

/* Dibuja una recta diagonal */

x=xinicial; /* Punto inicial */
y=yinicial;
i=0;
/* Trazado hasta el punto final */
while (x+1)<=xfinal
Pág. 2
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

{
dibujarpunto(x+i,y+i);
i=i+1;
}
Si la pendiente de la recta fuese –1, se sustituye (y+i) por (y-i).

c) Rectas arbitrarias
Cuando trazamos rectas con pendientes arbitrarias nos encontramos con ciertos problemas.
Primero, debido a que las pantallas de presentación sólo pueden iluminar sólo en posiciones
de pixels, la presentación por barrido produce un efecto de escalera que lo que reproduce sólo
una aproximación a la recta real. Aunque puede resultar imposible encender pixels que
coincidan exactamente con la recta real, será importante encender aquellos pixels que se
encuentren muy cerca de la recta real. Pero, determinar los píxels más cercanos a la recta
real, no es fácil.
Existen diferentes algoritmos que buscan determinar la mejor aproximación de los pixels
respecto a la recta real. La elección del algoritmo depende de la velocidad de generación de
las rectas, además de la apariencia de las mismas.

METODO DIRECTO:
Se trata de usar la ecuación de la recta:

y  ( m  x)  b
donde:
m : pendiente de la recta
b : valor de la ordenada cuando la abscisa es igual a 0
Mediante la ecuación, determinamos primero la pendiente y la ordenada en el origen. La
recta se trazará entonces incrementando en una unidad el valor de x desde (xinicial,yincial)
hasta (xfinal,yfinal) resolviendo en cada paso el valor de y. Para cada valor coordenado (x,y)
calculado, se ilumina el pixel correspondiente invocado dibujarpunto(x,round(y)).
Round es una función que redondea el valor de y al entero mas cercano.
Este método presenta dos problemas importantes:
El tiempo computacional para el trazado de la recta, debido a las operaciones de
multiplicación y división que requieren un tiempo entre 50 a 200 veces mayor que una
operación de adición. En este método se requiere efectuar una división para el cálculo de la
pendiente y la ordenada
y
en le origen, lo cual se
Recta con pendiente
efectúa de manera 6
(3,6) mayor que 1.
simultánea, y m y x se
multiplican entre sí 5
para cada píxel de la
4
recta.
Un segundo problema 3
esta relacionado con las (2,3)
rectas que tienen 2
pendientes cuyo valor
absoluto es mayor que 1
(1,1)
1. Cuando las rectas se
0 4 5 6 x
asemejan cada vez mas 1 2 3
a la vertical, en cuyo
caso las rectas desplegadas mostrarán huecos entre los puntos dibujados.
Pág. 3
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

Para corregir estos problemas, se estudian varios métodos. La multiplicación repetida puede
eliminarse realizando cálculos incrementales en cada paso, tomando como base el paso
inmediato anterior. El segundo problema puede resolverse aumentando y en una unidad y
resolviendo la ecuación de la recta para x, si el valor absoluto de m es mayor que 1. Esta
solución nos llevaría a efectuar una operación de división en cada paso.

ADD SIMPLE (Analizador Diferencial Digital Simple)

Este algoritmo presenta un procedimiento de trazado de rectas que es fácil de programar y
que produce rectas razonablemente buenas.
Si queremos trazar la recta que va desde (xinicial, yinicial) y (xfinal, yfinal) cuya pendiente
es:

yfinal  yinicial
m
xfinal  xinicial

Cualesquiera dos puntos consecutivos (x1, y1), (x2, y2) en la recta cumplen con la ecuación:

y 2  y1
m
x 2  x1

Para abs(m)<1 y xinicial<xfinal, la línea se genera aumentando en una unidad el valor

anterior de x hasta llegar a xfinal, resolviendo y en cada paso. (Si xinicial>xfinal,, se
intercambia ambos puntos). Entonces para cada par de puntos consecutivos:

x2 = x1 + 1 o x2 – x1 = 1,

Al sustituir en la ecuación de la pendiente m, tenemos:

y 2  y1
m o y2 = y1 + m
1

Esta ecuación permite calcular valores sucesivos de y desde el valor anterior reemplazando la
multiplicación repetida con sumas en punto flotante.
Usar un valor anterior para calcular en valor actual es una gran ventaja al momento de
efectuar los cálculos.

Si abs(m)>1 y yinicial<yfinal, la recta se genera invirtiendo el procedimiento anterior. Es

decir se incrementa el valor de y en una unidad hasta que se alcanza el valor de yfinal y se
resuelve x. (si yinicial>yfinal se intercambian ambos extremos). Para dos puntos
consecutivos

y2 = y1 + 1 o y2 – y1 = 1.

Sustituyendo esta diferencia en la ecuación de la pendiente m:

1 1
m o x 2  x1 
x 2  x1 m

esta es la ecuación incremental de la recta analizada.

Pág. 4
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

void trazar_recta(int xinicial, int yinicial, int xfinal, int yfinal)

{
float xi,yi,xr,yr,m,minversa;

m=(yfinal-yinicial)/(xfinal-xinicial);
/* verificar que los valores iniciales estén antes de los finales */
If((abs(m)<1) && (xinicial>xfinal) || (abs(m)>1) && (yinicial>yfinal))
{
/* Intercambio de los extremos */
permutar(xinicial,yinicial,xfinal,yfinal);
}
/* grafica el primer punto */
dibujarpunto(xinicial,yinicial);
if abs(m)<1
{ /* incrementa los valores de x en 1*/
yr=yinicial;
for(xi=(xinicial+1);xi<=(xfinal-1))
{ /* calcula y, luego grafica los puntos */
yr=yr+m;
dibujarpunto(xi,round(yr));
}
}
else /* pendiente >1 */
{
minversa=1/m;
xr=xinicial;
for(yi=(yinicial+1);yi<=(yfinal-1))
{ /* calcula x y luego grafica los puntos */
xr=xr+minversa;
dibujarpunto(round(xr),yi);
}
}
/* grafica el último punto */
dibujarpunto(xfinal,yfinal);
}

El procedimiento para permutar los extremos sería:

void permutar(int x1, int y1, int x2, int y2)
{
int aux;
aux=x2;
x2=x1;
x1=aux;
aux=y2;
y2=y1;
y1=aux;
}

Pág. 5
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

ADD ENTERO
El ADD Simple presenta el inconveniente de emplear dos operaciones que resultan costosas
en el tiempo de computación. La adición en punto flotante y el procedimiento de redondeo
round().

El siguiente algoritmo hace uso de la aritmética entera para salvar estos problemas.

La idea fundamental del analizador diferencial digital entero consiste en reemplazar la

pendiente real siendo ésta calculada por sus componentes enteros. Esto significa que se debe
tomar los valores enteros de delta_y=yfinal – yinicial y delta_x=xfinal-xinicial y de esta
manera se evitará trabajar con aritmética de punto flotante.
Dependiendo de la pendiente de la recta, el algoritmo se divide en cuatro casos particulares y
cada caso tiene sus propios conjuntos de reglas. El parámetro del error indica la distancia que
hay entre la recta real y un punto graficado. Los extremos deben ordenarse como se indica en
cada caso.

Caso 1: y
Pendiente entre 0 y 1con delta_x y delta_y no negativos:
Si el error es negativo, grafíquese el punto localizado una
unidad a la derecha del punto anterior y agréguese delta_y al
error; de otra forma grafíquese el punto localizado una unidad f
arriba y una unidad a la derecha del punto anterior y agréguese i
delta_y – delta_x al error. x

Caso 2: y
f
Pendiente mayor que 1 con delta_x y delta_y no negativas:
Si el error es negativo, grafíquese el punto localizado una
unidad arriba y una unidad a la derecha del punto anterior y
agréguese delta_y – delta_x al error; de otra forma grafíquese el
punto una inidad arriba del punto anterior y réstese delta_x del
i
error. x

Caso 3: y
Pendiente ente –1 y 0 con delta_y no negativa y delta_x
negativa:
Si el error es negativo, grafíquese el punto una unidad a la
izquierda del punto anterior y agréguese delta_y al error; de otra f
forma, grafíquese el punto localizado una unidad arriba y una
unidad a la izquierda del punto anterior y agréguese delta_x + i
x
deta_y al error.

Caso 4: y
f
Pendiente menor que –1 con delta_y no negativa y delta_x
negativa:
Si el error es negativo, grafíquese el punto localizado una unidad
arriba y una unidad a la izquierda del punto previo y agréguese
delta_x + delta_y al error; de otra forma, grafíquese el punto una
i
unidad arriba del punto anterior y agréguese delta_x al error. x
El error es inicializado en 0 y se vuelve nuevamente 0 cuando
llega al final de la recta y siempre que el punto calculado coincide
con la recta real. Cada caso se vale del signo del error de manera diferente.
Ejemplo para el caso 2:
Pág. 6
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

XINICIAL = 2 XFINAL = 6
YINICIAL = 2 YFINAL = 7

DELTA_X = 4 DELTA_Y = 5
y
DELTA_Y – DELTA_X = 1
7
Iteraciones:
6 1. ERROR = 0
5 x=2
y=2+1=3
4 ERROR = 0 – 4 = -4
2. ERROR = -4
3
x=2+1=3
2 y=3+1=4
ERROR = -4 + 1 = -3
1 3. ERROR = -3
x=3+1=4
0 x y=4+1=5
1 2 3 4 5 6 7
ERROR = -3 + 1 = -2
ADD entero 4. ERROR = -2
x=4+1=5
y=5+1=6
ERROR = -2 + 1 = -1

este ejemplo muestra el trazado de la recta real (en rojo) y la recta trazada (usando el
algoritmo DDA entero) entre los puntos (2,2) y (6,7). Cualquier recta que se ajuste al caso 2,
se dirige más hacia arriba (dirección y) que hacia la derecha (dirección x). En ningún
momento habrá más movimientos sobre x que sobre y, lo cual se ajusta a una recta con
pendiente mayor que 1.

El número de puntos graficados es delta_x + 1 para los casos 1 y 3, y delta_y + 1 para los
casos 2 y 4. El procedimiento add_entero traza una línea recta de acuerdo a este algoritmo.

void add_entero(int xinicial, int yinicial, int xfinal, int yfinal)

{
int delta_x, delta_y; /* razones de cambio */
int cuenta; /* número de puntos */
int n error; /* magnitud fuera de la línea */
int x,y ; /* puntos graficados */

/* inicialización */
error=0;
delta_x=xfinal-xinicial;
delta_y=yfinal-yinicial;
/* Verifica si delta_y no negativo */
if delta_y<0
{ /* intercambia extremos */
permutar(xinicial,yinicial,xfinal,yfinal);
/* actualiza adecuadamente los valores de los deltas */
delta_y= -delta_y;
Pág. 7
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

delta_x= -delta_x;
}
dibujarpunto(xinicial,yinicial); /* primer punto */
/* inicializa los valores de x e y */
x=xinicial;
y=yinicial;
if delta_x>=0
/* Caso 1 ó 2 */
if delta_x>=delta_y
/* Caso 1 */
for(cuenta=1;cuenta<=(delta_x-1);cuenta++)
/* grafica arriba del último punto */
if error<0
{
x=x+1;
dibujarpunto(x,y);
error=error+delta_y;
}
else /* error >=0 */
{
x=x+1;
y=y+1;
dibujarpunto(x,y);
error=error+delta_y-delta_x;
}
else /* Caso 2 */
for(cuenta=1;cuenta<=(delta_y-1);cuenta++)
/* grafica puntos */
if error<0
{
x=x+1;
y=y+1;
dibujarpunto(x,y);
error=error+delta_y-delta_x;
}
else /* error >=0 */
{
y=y+1;
dibujarpunto(x,y);
error=error-delta_x;
}
else /* Caso 3 o Caso 4 */
if delta_x>=delta_y
/* Caso 3 */
for(cuenta=1;cuenta<=(delta_x-1);cuenta++)
/* grafica puntos */
if error<0
{
x=x -1;
dibujarpunto(x,y);
error=error+delta_y;
}
Pág. 8
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

else /* error >=0 */

{
x=x-1;
y=y+1;
dibujarpunto(x,y);
error=error+delta_x+delta_y;
}
else /*Caso 4 */
for(cuenta=1;cuenta<=(delta_y-1);cuenta++)
/* grafica puntos */
if error<0
{
x=x-1;
y=y+1;
dibujarpunto(x,y);
error=error+delta_x+delta_y;
}
else /* error >=0 */
{
y=y+1;
dibujarpunto(x,y);
error=error+delta_x;
}
/* Grafica el último punto*/
dibujarpunto(xfinal,yfinal);
}

Procedimientos de trazados de rectas.

Todos los sistemas de despliegue gráfico cuentan con procedimientos que permiten al usuario
trazar rectas entre dos puntos. A estos procedimientos se les denomina comandos u órdenes
de graficación.
Algunas órdenes son:

dibujars(x,y)
traza un segmento de recta, donde x e y son valores enteros no negativos que representan las
coordenadas de pantalla del punto terminal de la recta.

moverp(x,y)
Este procedimiento permite posicionarse en un pixel ubicado en la pantalla en la posición
(x,y).

Por ejemplo, para trazar una recta de (2,6) a (15,120), se debe ejecutar las órdenes:
moverp(2,6);
dibujars(15,120);

d) Trazado de Círculos:
REPRESENTACIÓN IMPLÍCITA
Un círculo se traza tomando en cuenta las coordenadas de su centro (x,y) y de su radio r. La
ecuación del círculo de uso más generalizado es:
x  xc 2   y  yc 2  r 2
Pág. 9
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

Si el centro se ubica en el origen de coordenadas (0,0) se tendría:

x2  y2  r 2
Resolviendo la ecuación para y,
y  yc  r 2  x  xc 
2

para dibujar un círculo, se incrementan los valores de x en una unidad desde –r hasta +r
buscando obtener los dos valores de y en cada paso haciendo uso de las ecuaciones
anteriores. Es importante convertir a enteros los valores antes de trazar el círculo.
Este método no es muy eficiente debido a que:
 No se aprovecha la simetría de los círculos
 Cantidad de tiempo de procesamiento elevado debido a los cálculos de potenciación y
radicación.
 Si se trata un cuadrante de un círculo con centro en el origen se apreciará que aunque
los valores de x están igualmente espaciados (en una unidad), no sucede lo mismo
con y. El círculo es denso y plano cerca del eje y, y presenta grandes huecos cerca al
eje x.
Suponiendo que el centro está en el origen, el cambio de los valores de y puede relacionarse
x
con el cambio en x a través de la ecuación diferencial dy   dx . El cambio en x, o dx, se
y
establece en una unidad.
A medida que x tiende a cero, el valor de dy se vuelve muy pequeño. Esto explica el
fenómeno antes mencionado. Si los valores de x se acercan a r, entonces y tiende a cero
(porque x 2  y 2  r 2 ) con lo cual dy se hace muy grande y esto hace aparecer grandes
vacíos o huecos en el trazado del círculo.
y

0 x

REPRESENTACIÓN PARAMÉTRICA POLAR

El problema que se presenta en el caso anterior, de generar espaciados no equitativos, se puede
eliminar empleando una representación polar: (x3,y3)

x  xc  r cosα
y  yc  r senα (x2,y2)
d r
donde  se mide en radianes desde 0 hasta 2 ya que Longitud de arco
la longitud del arco es igual a r y el radio r es d 
constante. Los incrementos iguales de  , d, (x1,y1)
originan un espaciamiento uniforme (longitud de
arco) entre los puntos graficados sucesivamente.
La desventaja de este método radica en el tiempo de procesamiento para el cálculo repetido de
los valores de cos() y sen().

Pág. 10
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

Trazado incremental:
El problema del método anterior (cálculo repetido de los valores de cos() y sen()) se salva usando
métodos incrementales que permiten calcular las coordenadas de los puntos de un círculo a partir de
los puntos calculados anteriormente. Para ello se requiere calcular sólo una vez los valores de cos()
y sen().

Con fines didácticos, consideraremos el centro del círculo en el origen de coordenadas.

Dos puntos consecutivos (x1,y1) y (x2,y2) en un círculo están relacionados por:
x1 = r cos()
y1 = r sen()
x2 = r cos(+d)
y2 = r sen(+d)

donde d es un paso angular de tamaño fijo.

Haciendo uso de las identidades trigonométricas, se obtiene:

x2 = r cos()cos(d) – r sen()sen(d)
y2 = r sen()cos(d) + r cos()sen(d)

Reemplazando las primeras identidades tenemos:

x2 = x1 cos(d) – y1 sen(d)
y2 =y1 cos(d) + x1 sen(d)

Tales son las ecuaciones incrementales que deseamos para generar un círculo.
Al iniciar el círculo en x1=0 , y y1=r, con un incremento angular fijo d, pueden calcularse todos
los puntos del círculo calculando cos(d) sólo una vez.
Antes de utilizar esas ecuaciones para dibujar un círculo, se debe tener en cuenta la simetría. Si un
punto (a,b) coincide con el círculo x2 + y2 = r2 centrado en el origen, entonces lo mismo ocurre con
otros siete puntos: (-a,b), (a,-b), (-a,-b), (b,a), (-b,a), (b,-a), (-b,-a), como se observa en la figura:

(Para verificar esto, substitúyase los ocho puntos en la ecuación del círculo).
Se aprovecha esta simetría calculando valores sólo para un octavo del círculo, esto es, un intervalo
angular de 45 grados. Si el primer punto está en (0,r), los cálculos llegan a su fin cuando y = x.
Para hallar los puntos simétricos de un círculo centrado en (xc,yc), se añade xc a la primera
coordenada y yc a la segunda para cada uno de los ocho puntos.
El siguiente procedimiento, Circulo, calcula los puntos de un círculo centrado en el origen,
para después sumar los valores de xc a x y yc a y, desplazado el centro hacia (xc,yc). Para hacer que
el círculo aparezca como tal, los valores de y se multiplican por el formato de imagen antes de
proceder a dibujar. Dado que se usan coordenadas enteras en pantalla, el radio es una distancia
entera desde el centro del círculo (de no ser este el caso, use la función round). Lo deseable es un
espaciamiento aproximado de una unidad entre puntos adyacentes. Esto significa que la longitud del

Pág. 11
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

arco, r × dα, debe ser una unidad; por lo tanto, dα debe ser 1/radio. Antes de utilizar este
procedimiento, debemos comprobar que el círculo se halla dentro de los límites de la pantalla. Esto
se logra comparando xc ± r y yc ± r con las coordenadas de pantalla horizontales y verticales
máximas, respectivamente.
void circulo(int. xc,int yc,int radio) // centro y radio del círculo
{
const float fi=1.33; //formato de imagen
float dalfa, // incremento angular
ct,st, // coseno y seno de dα
x,y, // puntos calculados
xtemp; // almacén de datos anteriores de x
// inicialización
dalfa=1/radio;
ct=cos(dalfa);
st=sin(dalfa);
/* Coordenadas iniciales */
x=0;
y=radio;
while (y>x)
{
dibujarpunto(round(xc+x),round(yc+y*fi));
dibujarpunto(round(xc-x),round(yc+y*fi));
dibujarpunto(round(xc+x),round(yc-y*fi));
dibujarpunto(round(xc-x),round(yc-y*fi));
dibujarpunto(round(xc+y),round(yc+y*fi));
dibujarpunto(round(xc-y),round(yc+y*fi));
dibujarpunto(round(xc+y),round(yc-y*fi));
dibujarpunto(round(xc-y),round(yc-y*fi));
/* Calcula x e y nuevas */
xtemp=x;
x=(x*ct-y*st);
y=(y*ct+xtemp*st);
}
}

También puede trazarse un círculo por medio de numerosos segmentos de recta. Estableciendo el
número de segmentos igual a una
cantidad constante de veces el
radio, los círculos mas grandes
se verán tan perfectos como los
pequeños. En general, cuanto
mayor sea el valor de la
constante multiplicadora, más
―suave‖ será el círculo (mayor
número de segmentos más
pequeños).

void trazar_circ(int xc,int yc,int radio)

{
const float dos_pi=6.28318;
const float fi=1.33;
Pág. 12
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

float dalfa, ct, st;

int cont, x, y, xtemp;
dalfa=dos_pi/16*radio;
ct=cos(dalfa);
st=sin(dalfa) ;
x=0;
y=radio;
moverp(xc+x,round(yc+y*fi));
for(cont=1;cont<=16*radio;cont++)
{
xtemp=x;
x=(x*ct - y*st);
y=(y*ct + xtemp*st);
dibujars(round(xc+x),round(yc+y*fi));
}
}

El procedimiento anterior dibuja un círculo cuya constante multiplicativa es de 16, resultando en 16

× radio segmentos de recta.

ALGORITMO DE BRESENHAM PARA CÍRCULOS

Este es un algoritmo muy eficiente. Fue diseñado por J. Bresenham. Los valores de un círculo
centrado en el origen se calculan en un sector de 45 grados desde
x=0 hasta x=radio/ 2 . Los siete sectores restantes se obtienen por la
simetría de ocho puntos en el círculo.
En la figura se observa que los valores de y se decrementan cuando x
se incrementa desde x=0 hasta x= r/ 2 . Por lo tanto, si (0,r) es el
punto inicial del algoritmo, entonces, a medida que x se incrementa
en una unidad (pixel), los valores de y correspondientes permanecen
ya sea sin cambio o decrementados en una unidad. En particular, si
(xi,yi) es un píxel en el círculo, el siguiente píxel que describe el
x círculo es A o B.

A: (xi + 1 , yi ); a la derecha del punto anterior

B: (xi + 1 , yi - 1); abajo y a la derecha del punto anterior.

El algoritmo procede ahora a escoger el píxel A o B calculando y comparando las distancias de cada
píxel con respecto al punto en el círculo cuyo valor de x sea de xi + 1. Como estas distancias miden
cuán lejos del círculo se encuentra cada píxel, el píxel con la distancia más pequeña representa la
mejor aproximación al círculo.
El cuadrado de la distancia del píxel A respecto del centro del círculo (el origen en este caso) es

(xi + 1)2 + yi2 .

De lo anterior puede concluirse que la diferencia entre esta distancia al cuadrado y la distancia al
cuadrado del punto más cercano al círculo es de

d(A)= (xi + 1)2 + yi2 – r2

Del mismo modo se obtiene la ecuación para el píxel B:

Pág. 13
Facultad de Ingeniería – UNJBG E.P. Ingeniería en Informática y Sistemas

d(B)= (xi + 1)2 + (yi - 1 )2 – r2

Un punto coincide con el círculo si su valor d es igual a 0. De acuerdo con lo expuesto

anteriormente, se desea escoger cualquier píxel A o B que tenga el valor d más pequeño. Para esto se
analiza la suma

s = d(A) + d(B)..

Son tres los casos por considerar:

a. Si el círculo pasa entre A y B, entonces d(A) > 0 y d(B) < 0. Si abs(d(A)) > abs(d(B)),
entonces debe escogerse B, ya que se trata del punto más cercano al círculo. En este caso
s>0. No obstante, si abs(d(A)) ≤ abs(d(B)), entonces se debe seleccionar A y s≤0.
b. Si el círculo pasa por o sobre A, entonces d(A)≤0 y d(B)<0. Aquí, A es obviamente la
mejor opción (s<0).
c. Si el círculo pasa por o bajo B, entonces d(A)>0 y d(B)≥0. B es aquí la mejor opción
(s>0).

De estos casos pasamos a la regla siguiente: si s>0, se escoge el píxel B; de ser otro el caso, se
escoge el píxel A.

1.4. ELIPSES
La elipse es una variación del círculo. Si examinamos elipses que se extienden en las
direcciones x o y. Las ecuaciones polares de este tipo de elipse centrada en (xc,yc) son:

x = xc + a × cos(α)
y = yc + b × sen(α)

Donde el ángulo α adopta valores entre 0 y 2π radianes.

Los valores de a y b determinan el contorno de la

elipse. si b>a, la elipse se alarga en la dirección
b
de y. Si, por el contrario, b<a, la elipse se
extiende en la dirección de x. Puede dibujarse la
α elipse empleando una simetría de cuatro puntos:
(xc,yc) a si (c;d) coincide con la elipse, lo mismo ocurre
con los puntos (-c;d) , (c;-d) y (-c;-d).
Las siguientes ecuaciones incrementales para una
elipse se derivan de las ecuaciones anteriores:
x2 = x1 cos(dα) – (a/b) y1 sen(dα)
y2 = y1 cos(dα) – (b/a) x1 sen(dα)

El procedimiento trazar_circ puede ser modificado para trazar una elipse empezando en x=0 y
y=b y reemplazando las ecuaciones del círculo por las ecuaciones incrementales de la elipse.

Pág. 14