Algoritmos Open GL para generación de gráficas.

Como todos saben Open GL es una herramienta que nos facilita mucho la generación de gráficos por computadora. Aqui aplicamos conocimientos matemáticos, usando Open GL para generar rectas, corcunferencias, elipses, etc.

1.1 DDA:

El Algoritmo DDA es un algoritmo de línea de conversión de rastreo que se basa en el cálculo ya sea en el incremento de X o en el incremento de Y. La finalidad de este algoritmo es determinar los valores enteros correspondientes más próximos a la trayectoria de la línea para la otra coordenada.

Código:

void DDA(int x0,int y0,int xFin,int yFin)

{

int dx = xFin - x0, dy = yFin - y0, steps, k;

float xIncremento, yIncremento;

float x = x0, y = y0;

if (fabs (dx) > fabs (dy))

steps = fabs (dx); /* |m|<1>

else

steps = fabs (dy); /* |m|>=1 */

xIncremento=float(dx)/float (steps);

yIncrement = float (dy) / float (steps);

setPixel (round (x), round (y));

for (k = 0; k <>

{

x += xIncremento;

y += yIncremento;

setPixel (round (x), round (y));

}

}

1.2 BRESENHAM:

El algoritmo de Bresenham sirve para trazar una línea entre dos puntos.

Código:

void Bres(int x0,int y0,int xFin,int yFin)

{

int dx = fabs(xFin - x0),

dy = fabs(yFin - y0);

int p = 2 * dy - dx;

int dosDy = 2 * dy,

dosDyMenosDx = 2 * (dy - dx);

int x, y;

/* Determinamos que punto usamos como inicio. */

if (x0 > xFin) {

x = xFin;

y = yFin;

xFin = x0;

}

else {

x = x0;

y = y0;

}

setPixel (x, y);

while (x <>

x++;

if (p <>

p += dosDy;

else {

y++;

p += dosDyMenosDx;

}

setPixel (x, y);

}

}

1.3 PUNTO MEDIO PARA CIRCULOS:

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 del muestreo.Además sincroniza el dibujado de los píxeles en cada octante de la circunferencia.

Código:

void circuloPtoMedio(scrPt circCtr, GLint radio)

{

scrPt circPt;

GLint p = 1 - radio;

circPt.x = 0;

circPt.y = radio;

void circuloPuntos(scrPt, scrPt);

/* Dibujamos el punto inicial en cada cuadrante del circulo*/

circuloPuntos(circCtr, circPt);

/* Calculamos los siguientes puntos y los dibujamos en cada octante*/

while (circPt.x <>

circPt.x++;

if (p <>

p += 2 * circPt.x + 1;

else {

circPt.y--;

p += 2 * (circPt.x - circPt.y) + 1;

}

circuloPuntos(circCtr, circPt);

}

}

void circuloPuntos(scrPt circCtr, scrPt circPt);

{

setPixel (circCtr.x + circPt.x, circCtr.y + circPt.y);

setPixel (circCtr.x - circPt.x, circCtr.y + circPt.y);

setPixel (circCtr.x + circPt.x, circCtr.y - circPt.y);

setPixel (circCtr.x - circPt.x, circCtr.y - circPt.y);

setPixel (circCtr.x + circPt.y, circCtr.y + circPt.x);

setPixel (circCtr.x - circPt.y, circCtr.y + circPt.x);

setPixel (circCtr.x + circPt.y, circCtr.y - circPt.x);

setPixel (circCtr.x - circPt.y, circCtr.y - circPt.x);

}

1.4 PUNTO MEDIO PARA ELIPSES

Expresado de forma ambigua, una elipse es una circunferencia alargada. Por lo tanto, las curvas elípticas se pueden generar al modificar los procedimientos para el trazo de circunferencias con el fin de considerar las diversas dimensiones de una elipse a lo largo de los ejes mayor y menor.

Codigo:

void puntomedioElipse(int xc,int yc,int rx, int ry)

{

int Rx2 = rx*rx; //rx^2

int Ry2 = ry*ry; //ry^2

int DosRx2 = 2*Rx2; //2rx^2

int DosRy2 = 2*Ry2; //2ry^2

int p1;

int p2;

int x = 0;

int y = ry;

int px = 0; //2ry^2

int py = DosRx2 * y; //2rx^2*ry

//Region 1

p1=Ry2-(Rx2*ry) + (0.25*Rx2);

while (px <>

x++;

px = px + DosRy2;

if (p1 <>

p1 = p1 + Ry2 + px;

else {

y--;

py = py - DosRx2;

p1 = p1 + Ry2 + px - py;

}

setPixel(xc+x,yc+y);

setPixel(xc-x,yc+y);

setPixel(xc+x,yc-y);

setPixel(xc-x,yc-y);

}

//Region 2

p2=Ry2*(x+0.5)*(x+0.5) + Rx2*(y-1)*(y-1)-Rx2*Ry2;

while (y > 0){

y--;

py = py - DosRx2;

if (p2 > 0)

p2 = p2 + Rx2 - py;

else {

x++;

px = px + DosRy2;

p2 = p2 + Rx2 - py + px;

}

setPixel(xc+x,yc+y);

setPixel(xc-x,yc+y);

setPixel(xc+x,yc-y);

setPixel(xc-x,yc-y);

}

}

1.5 TRANSFORMACIONES

Traslacion:(verde) las traslaciones son movimientos directos, es decir, mantienen la forma y el tamaño de las figuras, a las cuales deslizan según el vector t.

Código:

int Xo,Yo,Xfin,Yfin;

int Tx=10,Ty=15,Sx=2,Sy=3,angulo=37;

void traslacion()

{

glBegin(GL_LINES);

glColor3f(0.0,1.0,0.0);

glVertex2i(Xo+Tx,Yo+Ty);

glVertex2i(Xfin+Tx,Yfin+Ty);

glEnd();

glFlush();

}

Rotacion:(negro) las rotaciones son movimientos directos, es decir, mantienen la forma y el tamaño de las figuras. El sentido de rotación puede ser positivo (en contra del sentido horario) o negativo (a favor del sentido horario).

Código:

int Xo,Yo,Xfin,Yfin;

int Tx=10,Ty=15,Sx=2,Sy=3,angulo=37;

void rotacion()

{ double Xp,Yp,Xp1,Yp1;

Xp=Xo*(cos(angulo)) - Yo*(sin(angulo));

Yp=Xo*(sin(angulo)) + Yo*(cos(angulo));

Xp1=Xfin*(cos(angulo)) - Yfin*(sin(angulo));

Yp1=Xfin*(sin(angulo)) + Yfin*(cos(angulo));

glBegin(GL_LINES);

glColor3f(0.0,0.1,0.0);

glVertex2i((int)Xp,(int)Yp);

glVertex2i((int)Xp1,(int)Yp1);

glEnd();

glFlush();

}

Escalado:(azul) con el escalamiento podemos aumentar/disminuir un objeto en cuanto a tamaño. Tan sólo tendremos que multiplicar a cada uno de sus coordenadas por una variable de escalamiento.

Código:

int Xo,Yo,Xfin,Yfin;

int Tx=10,Ty=15,Sx=2,Sy=3,angulo=37;

void escalado()

{

glBegin(GL_LINES);

glColor3f(0.0,0.0,1.0);

glVertex2i(Xo*Sx,Yo*Sy);

glVertex2i(Xfin*Sx,Yfin*Sy);

glEnd();

glFlush();

}