Algoritmo DDA para generación de líneas
Analizador Diferencial Digital (DDA) se usa para la interpolación lineal de veriables sobre un intervalo entre un punto de comienzo y un punto de fin.
Los DDAs se usan para rastreo de lineas, triangulos y polígonos. En la implementación mas simple del algoritmo DDA interpola valores en intervalo [(xinicio, yinicio), (xfin, yfin)] por calculo para cada xi las equaciónes xi = xi−1+1, yi = yi−1 + Δy/Δx, donde Δx = xfin − xinicio y Δy = yfin − yinicio.
Para correr el ejemplos tienes que descargar la libreria de clases The tao framework de aqui, lo descomprimen y buscan en la carpeta lib el archivo llamado freeglut.dll, lo copian y lo pengan en widows\system. Hecho todo esto, crean un nuevo proyecto en c# de consola y agregan las referencias hacia los archivos Tao.FreeGlut.dll y Tao.OpenGl.dll que se encuentran en la carpeta que descomprimieron "taoframework-2.1.
Y después el código
static double x1, y1, x2, y2;
main{
Console.WriteLine("introduzca el valor de X1");
x1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca el valor de Y1");
y1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca el valor de X2");
x2 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca el valor de Y2");
y2 = Convert.ToDouble(Console.ReadLine());
Glut.glutInit();//funciones propias de opengl
Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
Glut.glutInitWindowSize(640, 480);//creamos una ventana
Glut.glutCreateWindow("**************Algoritmo DDA**************");//colocamos titulo a la ventana
//llamamos a la funcion dda
Glut.glutDisplayFunc(dda);
Glut.glutMainLoop();
}
public static void dda()
{
//componentes necesarios de opengl
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);//limpia el buffer de la pantall
Gl.glColor3f(0.6F, 0.6F, 0.6F);//poner color a los pixeles
Gl.glLoadIdentity();//''muy importante;
Gl.glPointSize(2.0f);//medida de los puntos
Gl.glBegin(Gl.GL_POINTS);//funcion para dibujar puntos
//dibujando el plano
float z = -1, w = 1, c = 0;
for (int i = 0; i < 200; i++)
{
Gl.glColor3f(w, c, z);
Gl.glVertex2d(z, 0);
Gl.glVertex2d(0, w);
z += .01f;
w -= .01f;
c += .1f;
}
Gl.glEnd();//termina funcion para dibujar puntos
///pasamos las
Gl.glPointSize(5.0f);//sirve para el tamaño de los pixeles
Gl.glColor3f(0.6f, 1.0f, 0.6f);//sirve para el color de los pixeles
ddaDibujar(x1, y1, x2, y2);
}
public static void ddaDibujar(double x1,double y1,double x2, double y2)
{
double xinicial = x1, yinicial = y1, xfinal = x2, yfinal = y2,x,y;
double deltax, deltay, xincremento, yincremento;
double pasos;
deltax = xfinal - xinicial;
deltay = yfinal - yinicial;
if (Math.Abs(deltax) > Math.Abs(deltay))
pasos = Math.Abs(deltax);
else
pasos = Math.Abs(deltay);
xincremento = (deltax / pasos) / 10;
yincremento = (deltay / pasos) / 10;
x = xinicial;
y = yinicial;
Gl.glBegin(Gl.GL_POINTS);
Gl.glVertex2d(x, y);//funcion que pinta un pixel en las coordenadas especificadas
for (double k = .1; k <= pasos; k += .1)
{
x = (x + xincremento);
y = (y + yincremento);
Gl.glVertex2d(x, y);
}
Gl.glEnd();
//termina dda
}
Resultados
Algoritmo de Bresenham para trazar lineas
Este algorimo a diferencia del anterior sirve para trazar una linea entre dos puntos especificados en el codigo
Aqui se dara un ejemplo de como desarrollarlo en openGL
Basicamente lo que desarrolla es lo que el dibujo de abajo muestra
main{
Console.WriteLine("introduzca el valor de X1");
x1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca el valor de Y1");
y1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca el valor de X2");
x2 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca el valor de Y2");
y2 = Convert.ToDouble(Console.ReadLine());
//inicializar todo esto para tao opengl
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
Glut.glutInitWindowSize(640, 480);
Glut.glutCreateWindow("**************Bresenham**************");
//termina inicializacion de componentes tao opengl
Glut.glutDisplayFunc(Bresen);
Glut.glutMainLoop();
}
public static void Bresen()
{
//componentes necesarios
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
Gl.glColor3f(0.6F, 0.6F, 0.6F);
Gl.glLoadIdentity();
Gl.glBegin(Gl.GL_POINTS);
//dibujando el plano
float z = -1, w = 1, c = 0;
for (int i = 0; i < 200; i++)
{
Gl.glColor3f(w, c, z);
Gl.glVertex2d(z, 0);
Gl.glVertex2d(0, w);
z += .01f;
w -= .01f;
c += .1f;
}
Gl.glEnd();
Gl.glPointSize(5.0f);
Gl.glColor3f(1.0f, 0.111f, 1.0f);
BresenDibujar(x1, y1, x2, y2);
}
public static void BresenDibujar(double x1,double y1,double x2,double y2)
{
double xinicial = x1, yinicial = y1, xfinal = x2, yfinal= y2, x=0, y=0;
double deltax, deltay, constanteP,ultimo;
deltax = Math.Abs( xfinal - xinicial);
deltay =Math.Abs( yfinal - yinicial);
constanteP = 2 * deltay - deltax;
if (xinicial > xfinal)
{
x = xfinal;
y = yfinal;
ultimo = xinicial;
}
else
{
x = xinicial;
y = yinicial;
ultimo = xfinal;
}
Gl.glBegin(Gl.GL_POINTS);
//Gl.glColor3f(1f, 1.0f, .5f);
Gl.glVertex2d(x, y);
while (x < ultimo)
{
x += .1;
if (constanteP < 0)
constanteP +=2 * deltay;
else
{
y += .1;
constanteP += 2 * (deltay - deltax);
}
Gl.glVertex2d(x, y);
}
Gl.glEnd();
}
Resultados
Algorimo para desarrollar circunferencias
El algoritmo de línea de Bresenham se adapta a la generación de circunferencias al establecer los parámetros de decisión para identificar el pixel más cercano a la circunferencia en cada paso delmuestreo.Además sincroniza el dibujado de los píxeles en cada octante de la circunferencia.
static double x1, y1, x2, y2;
main{
Console.WriteLine("introduzca x");
xc = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca y");
yc = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca r");
r = Convert.ToDouble(Console.ReadLine());
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
Glut.glutInitWindowSize(500, 500);
Glut.glutCreateWindow("**************Circulo**************");
Glut.glutDisplayFunc(circulo);
Glut.glutMainLoop();
xc = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca y");
yc = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca r");
r = Convert.ToDouble(Console.ReadLine());
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
Glut.glutInitWindowSize(500, 500);
Glut.glutCreateWindow("**************Circulo**************");
Glut.glutDisplayFunc(circulo);
Glut.glutMainLoop();
}
public static void circulo()
{
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
Gl.glColor3f(0.6F, 0.6F, 0.6F);
Gl.glLoadIdentity();
Gl.glPointSize(5f);
Gl.glBegin(Gl.GL_POINTS);
float z = -1, w = 1, c = 0;
for (int i = 0; i < 200; i++)
{
Gl.glColor3f(w, c, z);
Gl.glVertex2d(z, 0);
Gl.glVertex2d(0, w);
z += .01f;
w -= .01f;
c += .1f;
}
//mandar los puntos
circuloAlgoritmo(xc, yc,r);
Gl.glEnd();
}
public static void circuloAlgoritmo(double xc, double yc, double r)
{
double x = 0;
double y = r;
double p = 0.1f - r;
pintar(xc, yc, x, y);
while (x < y)
{
x+=.1f;
if (p < 0)
p += .2f * x + .1f;
else
{
y-=.1f;
p += .2f * (x - y) + .1f;
}
pintar(xc, yc, x, y);
}
}
//Creamos el metodo pintar:
public static void pintar(double xc, double yc, double x, double y)
{
Gl.glColor3f(1f, .6f, 1f);
Gl.glVertex2d(xc + x, yc + y);
Gl.glVertex2d(xc - x, yc + y);
Gl.glVertex2d(xc + x, yc - y);
Gl.glVertex2d(xc - x, yc - y);
Gl.glColor3d(0f, .6f, 1f);
Gl.glVertex2d(xc + y, yc + x);
Gl.glVertex2d(xc - y, yc + x);
Gl.glVertex2d(xc + y, yc - x);
Gl.glVertex2d(xc - y, yc - x);
}
http://opengl.blogspot.es/
http://dariatodoloqueseporloquenose.blogspot.com/2008/12/algoritmos-open-gl-para-generacin-de.html
public static void circulo()
{
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
Gl.glColor3f(0.6F, 0.6F, 0.6F);
Gl.glLoadIdentity();
Gl.glPointSize(5f);
Gl.glBegin(Gl.GL_POINTS);
float z = -1, w = 1, c = 0;
for (int i = 0; i < 200; i++)
{
Gl.glColor3f(w, c, z);
Gl.glVertex2d(z, 0);
Gl.glVertex2d(0, w);
z += .01f;
w -= .01f;
c += .1f;
}
//mandar los puntos
circuloAlgoritmo(xc, yc,r);
Gl.glEnd();
}
public static void circuloAlgoritmo(double xc, double yc, double r)
{
double x = 0;
double y = r;
double p = 0.1f - r;
pintar(xc, yc, x, y);
while (x < y)
{
x+=.1f;
if (p < 0)
p += .2f * x + .1f;
else
{
y-=.1f;
p += .2f * (x - y) + .1f;
}
pintar(xc, yc, x, y);
}
}
//Creamos el metodo pintar:
public static void pintar(double xc, double yc, double x, double y)
{
Gl.glColor3f(1f, .6f, 1f);
Gl.glVertex2d(xc + x, yc + y);
Gl.glVertex2d(xc - x, yc + y);
Gl.glVertex2d(xc + x, yc - y);
Gl.glVertex2d(xc - x, yc - y);
Gl.glColor3d(0f, .6f, 1f);
Gl.glVertex2d(xc + y, yc + x);
Gl.glVertex2d(xc - y, yc + x);
Gl.glVertex2d(xc + y, yc - x);
Gl.glVertex2d(xc - y, yc - x);
}
Resultados
Referencias
http://opengl.blogspot.es/
http://dariatodoloqueseporloquenose.blogspot.com/2008/12/algoritmos-open-gl-para-generacin-de.html
No hay comentarios:
Publicar un comentario