TRABAJO DE INVESTIGACIN

LUIS MIGUEL SAENZ MORENO

Docente
ANGEL VARON

CORPORACIN UNIFICADA NACIONAL DE EDUCACIN SUPERIOR - CUN

COMPUTACION GRAFICA 2
INGENIERA DE SISTEMAS
BOGOT DC

2015

Desratizacin circunferencia.
La desratizacin de circunferencias o crculos es posible trabajar un slo segmento de
la circunferencia y se obtienen las dems por simetra. Igualmente se dispone de algoritmos
DDA y de Bressenham para el dibujo de circunferencias.

Segmento de circunferencia DDA.

Se mostrar una adaptacin del algoritmo DDA a partir de la ecuacin de la circunferencia,
Para poder realizar el dibujo de la circunferencia usaremos las ecuaciones de la circunferencia
en coordenadas polares que son:
x = r * cos
y = r *sen

Estas ecuaciones sern las que ocuparemos para calcular cada punto (x,y) del crculo, donde
el r ser obviamente el radio de crculo y q ser el ngulo que forma el radio con la parte
positiva del eje x. En forma grfica sera as:

El ngulo deber estar en radianes ya que las funciones de seno y coseno que incluye Java,
trabajan con los ngulos en radianes. La frmula para transformar grados a radianes es la
siguiente:

Entonces para dibujar el crculo de un radio determinado, solamente tenemos que hacer un ciclo
desde 0 hasta 360, pero con incrementos pequeos, calcular cada punto con las ecuaciones
en coordenadas polares e ir dibujando cada punto. El ciclo en vez de ir de 0 a 360 (ngulos en
grados) ir de 0 a 6.28 (360*3.14/180=6.28) ya que el ngulo debe estar en radianes.
Como dijimos el ciclo de 0 a 6.28 debe hacerse con incrementos pequeos, no contando de uno
en uno, ya que para un crculo de radio muy grande, podran aparecer huecos entre un punto y
el siguiente, por lo tanto tenemos que usar un incremento fraccionario. El valor 0.005 produce
buenos resultados. Dibujar el
Crculo punto a punto es una tarea un poco lenta, debido a que se debe calcular en cada punto
el seno y el coseno del ngulo, y estas funcionas son muy lentas. Para solucionar esto se
pueden crear tablas predefinidas o precalculadas.

Algoritmo adaptado a Java.

public void paint(Graphics g)

{
super.paint(g);
double x,y;
double angulo=0;
do
{
x= P.getX() + this.radio * (float) Math.cos(angulo);
y= P.getY() + this.radio * (float) Math.sin(angulo);
g.setColor(Color.blue);
g.drawRect((int) x , (int) y, 0,0);
angulo = angulo + 0.005;
}while(angulo < 6.8);
g.drawString(P.Coordenadas(), 50, 50);
}

Segmento de polgono DDA.

Un polgono regular se compone de aristas/lados de igual longitud. Esto implica que el ngulo
entre cada arista contigua es el mismo. Si trazamos un segmento del centro a un vrtice y otro
segmento del centro a otro vrtice contiguo, entonces el ngulo entre estos dos segmentos es
un divisor de 2 = 360. En otras palabras, cada ngulo mencionado es inversamente
proporcional a la cantidad de lados del polgono regular. Podemos usar la siguiente frmula: =
2 / N, donde es el ngulo, y N es la cantidad de lados Crearemos polgonos regulares en base
a una circunferencia que circunscribe nuestro polgono regular. Esto implica, que el centro de la

circunferencia coincide con el centro geomtrico de cualquier polgono regular. Para esto,
necesitamos usar algunas funciones trigonomtricas, junto con el ngulo ya calculado. El
paso principal es averiguar la coordenada del siguiente vrtice de nuestro polgono.
Usaremos las siguientes frmulas:
x i = cx + r * cos( i* )
y i = cy + r * sen( i* )
donde:
i = 0,1,2,...,N-1,
r es el radio de la circunferencia, y
c = (cx, cy) es la coordenada del centro geomtrico de la circunferencia y del polgono.
Al agregar el centro a nuestra frmula, conseguimos mover el centro geomtrico
del origen (0,0) al que nosotros deseemos.

Algoritmo adaptado en java

public void paint(Graphics g) {
super.paint(g);
for(int t=1;t<=this.Lados-1;t++)
{
int dx=0,dy=0;
int x1 = vertices[t].getX();
int x0 = vertices[t-1].getX();
int y1 = vertices[t].getY();
int y0 = vertices[t-1].getY();
dx = x1 - x0;
dy = y1 - y0;
if (Math.abs(dx) > Math.abs(dy))
{
float m = (float) dy / (float) dx;
float b = y0 - m * x0;
if(dx<0)
dx = -1;
else
dx = 1;
while (x0 != x1)
{
x0 += dx;
y0 = Math.round(m*x0 + b);
g.drawLine( x0, y0, x0, y0);
}

} else
if (dy != 0)
{
float m = (float) dx / (float) dy;
float b = x0 - m*y0;
if(dy<0)
dy = -1;
else
dy = 1;
while (y0 != y1)
{
y0 += dy;
x0 = Math.round(m * y0 + b);
g.drawLine( x0, y0, x0, y0);
}
}
}//fin for
if (this.Lados>0)
g.drawLine( vertices[this.Lados -1].getX(), vertices[this.Lados -1].getY(), vertices[0].getX(),
vertices[0].getY());
}

private void Poligonos()

{
double alfa;
int a, b;
vertices = new Punto[this.Lados];
alfa = 2 * Math.PI / this.Lados;
for(int i=0;i<=this.Lados-1;i++)
{
a= this.X + (int) (this.Radio * Math.cos((i - 1) * alfa));
b= this.Y + (int) (this.Radio * Math.sin((i - 1) * alfa));
vertices[i]= new Punto(a,b);
}