--------------------------------------------------------------------------------

-
Examen de Graficacion por Computadora
Nombres:
Hernndez Ramrez Miriam
Valencia Cordoba Juan Carlos
Valencia Cordoba Jos Alberto
Salgado Mendoza Jorge
--------------------------------------------------------------------------------
-
1. Programe el Algoritmo DDA en OpenGL, dando desde el programa los puntos inici
al y final.
public void init(GLAutoDrawable drawable) {
final GL gl = drawable.getGL();
final GLU glu = new GLU();
gl.glMatrixMode (GL.GL_PROJECTION);
gl.glClearColor (1.0f, 1.0f, 1.0f, 0.0f);
glu.gluOrtho2D (0.0, 200.0, 0.0, 150.0);
}
public void display(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
GLUT glut = new GLUT();
gl.glClear (GL.GL_COLOR_BUFFER_BIT);
gl.glColor3f (0.0f, 0.0f, 0.0f); //
gl.glMatrixMode (GL.GL_MODELVIEW);
gl.glLoadIdentity();
cuadro(gl);
paint(gl);
}
void cuadro(GL gl){
int i;
for(i=0;i<=250;i+=4){
gl.glLineWidth(2);
gl.glBegin(GL.GL_LINES);
gl.glColor3f(0.0f,0.0f,0.0f);
gl.glVertex2f(i,0);
gl.glVertex2f(i,250);
gl.glVertex2f(0,i);
gl.glVertex2f(250,i);
gl.glEnd();
}
}
public void paint(GL gl)
{
xini=50;
yini=50;
xfin=146;
yfin=138;
puntoI(gl, xini, yini);
puntoI(gl, xfin, yfin);
linea(gl, xini, yini, xfin, yfin);
correDDA(gl,xini,yini,xfin,yfin);
}
public void punto(GL gl,int xi,int yi)
{
gl.glPointSize(4);
gl.glBegin(GL.GL_POINTS);
gl.glColor3d(255/255.0, 255/255.0, 9/255.0);
gl.glVertex2f(xi,yi);
gl.glEnd();
}
public void puntoI(GL gl,int xi,int yi)
{
gl.glPointSize(10);
gl.glBegin(GL.GL_POINTS);
gl.glColor3f(1.0f, 0.0f, 0.0f);
gl.glVertex2f(xi,yi);
gl.glEnd();
}
public void linea(GL gl,int xini, int yini, int xfin, int yfin)
{
gl.glLineWidth(10);
gl.glBegin(GL.GL_LINES);
gl.glColor3d(49/255.0, 43/255.0, 179/255.0);
gl.glVertex2f(xini,yini);
gl.glVertex2f(xfin,yfin);
gl.glEnd();
}
void correDDA(GL gl ,int xini ,int yini ,int xfin ,int yfin){
int dx = xfin - xini;
int dy = yfin - yini;
if (Math.abs(dx) > Math.abs(dy)) { // pendiente < 1
float m = (float) dy / (float) dx;
float b = yini - m*xini;
if(dx<0)
dx = -1;
else
dx = 1;
while (xini != xfin) {
xini += dx;
yini = Math.round(m*(xini) + b);
punto(gl, (xini), (yini));
xini=xini+1;
}
} else
if (dy != 0) { // slope >= 1
float m = (float) dx / (float) dy; // compute slope
float b = xini - m*yini;

if(dy<0)
dy = -1;
else
dy = 1;
while (yini != yfin) {
yini += dy;
xini = Math.round(m*yini + b);
punto(gl, (xini), (yini));
yini=yini+1;
}
}
}
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height
) {
}
public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean
deviceChanged) {
}
} // Fin de la Clase
2. Programe el Algoritmo Alpha en OpenGL, dando desde el programa los puntos ini
cial y final.
public void paint(GL gl)
{
xini=50;
yini=50;
xfin=146;
yfin=138;
puntoI(gl, xini, yini);
puntoI(gl, xfin, yfin);
linea(gl, xini, yini, xfin, yfin);
Alpha(gl);
}
void Alpha(GL gl)
{
int dx = xfin - xini, dy = yfin - yini;
int i,k;
float alpha, x = xini, y = yini, incremento;
if(Math.abs(dy)>Math.abs(dx)){
pasos = Math.abs(dy);
} else
{
pasos = Math.abs(dx);
}
contar=0;
for(k=1;k<=pasos;k++){
contar=1+contar;
incremento = 1f / pasos;
alpha = incremento;
for(i=0;i<=contar; i++)
{
punto(gl, (int) x, (int) y);
x = xini*(1-alpha) + xfin*alpha;
y = yini*(1-alpha) + yfin*alpha;
alpha += incremento;
}
}
}
3. Programe en un Applet el Algoritmo de Bresemham.
package Graficacion;
import java.applet.Applet;
//import java.applet.Applet;
import java.awt.Button;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
public class Bresenham extends Applet implements MouseListener,
ActionListener{
int xini, yini, xfin, yfin, pasos, contar;
int x, y, dx, dy, p, incE, incNE, stepx, stepy;
boolean puntos, procesos;
Button proceso;
void cuadro(Graphics g, Color c){
int i;
g.setColor(c);
for(i=0;i<=250;i+=10){
g.drawLine(i, 0, i, 250);
g.drawLine(0, i, 250, i);
}
}
public void Bresenham(Graphics g)
{
proceso.setEnabled(false);
dx = (xfin - xini);
dy = (yfin - yini);
/* determinar que punto usar para empezar, cual para terminar */
if (dy < 0) {
dy = -dy; stepy = -1;
}
else
{stepy = 1;}
if (dx < 0) {
dx = -dx; stepx = -1;
}
else
{stepx = 1;}
x = xini;
y = yini;
dibujaPunto(g,xini, yini,Color.black);
/* se cicla hasta llegar al extremo de la lnea */
if(dx>dy){
p = 2*dy - dx;
incE = 2*dy;
incNE = 2*(dy-dx);
while (x != xfin){
x = x + stepx;
if (p < 0){
p = p + incE;
}
else {
y = y + stepy;
p = p + incNE;
}
dibujaPunto(g,x, y,Color.YELLOW);
}
}
else{
p = 2*dx - dy;
incE = 2*dx;
incNE = 2*(dx-dy);
while (y != yfin){
y = y + stepy;
if (p < 0){
p = p + incE;
}
else {
x = x + stepx;
p = p + incNE;
}
dibujaPunto(g,x, y,Color.red);
}
}
}
@Override
public void init() {
procesos = puntos = false;
xini = xfin = yini = yfin = contar = 0;
pasos = 0;
addMouseListener(this);
proceso = new Button("<Proceso>");
proceso.addActionListener(this);
proceso.setLocation(280, 120);
proceso.setSize(50, 13);
add(proceso);
}
void dibujaPunto(Graphics g,int x, int y, Color c){
g.setColor(c);
g.fillRect(x*10, y*10, 10, 10);
}
@Override
public void mouseClicked(MouseEvent me)
{ }
@Override
public void mousePressed(MouseEvent me) {
if (me.getX()<250 && me.getY()<250){
xini = me.getX()/10;
yini = me.getY()/10;
}
}
@Override
public void mouseReleased(MouseEvent me) {
if(me.getX()<250 && me.getY()<250){
xfin = me.getX()/10;
yfin = me.getY()/10;
puntos = true;
repaint();
}
}
@Override
public void mouseEntered(MouseEvent me)
{ }
@Override
public void mouseExited(MouseEvent me)
{ }
@Override
public void paint(Graphics g){
if (puntos){
dibujaPunto(g, xini, yini, Color.blue);
dibujaPunto(g, xfin, yfin, Color.blue);
g.setColor(Color.black);
g.drawLine(xini*10+5, yini*10+5, xfin*10+5, yfin*10+5);
}
if (procesos){
Bresenham( g);
}
cuadro(g,Color.black);
}
@Override
public void update(Graphics g){
paint(g);
}
@Override
public void actionPerformed(ActionEvent ae) {
if(ae.getSource()==proceso){
procesos = true;
repaint();
}
}
}
4.Programe el Algoritmo de Bresenham en OpenGL, dando desde el programa los punt
os inicial y final.
int xini, yini, xfin, yfin, pasos, contar;
int x, y, dx, dy, p, incE, incNE, stepx, stepy;
public void paint(GL gl)
{
xini=50;
yini=50;
xfin=146;
yfin=138;
puntoI(gl, xini, yini);
puntoI(gl, xfin, yfin);
linea(gl, xini, yini, xfin, yfin);
Bresenham(gl);
}
public void Bresenham(GL gl )
{
dx = (xfin - xini);
dy = (yfin - yini);
/* determinar que punto usar para empezar, cual para terminar */
if (dy < 0) {
dy = -dy; stepy = -1;
}
else
{stepy = 1;}
if (dx < 0) {
dx = -dx; stepx = -1;
}
else
{stepx = 1;}
x = xini;
y = yini;
punto(gl,xini, yini);
/* se cicla hasta llegar al extremo de la lnea */
if(dx>dy){
p = 2*dy - dx;
incE = 2*dy;
incNE = 2*(dy-dx);
while (x != xfin){
x = x + stepx;
if (p < 0){
p = p + incE;
}
else {
y = y + stepy;
p = p + incNE;
}
punto(gl,x, y);
}
}
else{
p = 2*dx - dy;
incE = 2*dx;
incNE = 2*(dx-dy);
while (y != yfin){
y = y + stepy;
if (p < 0){
p = p + incE;
}
else {
x = x + stepx;
p = p + incNE;
}
punto(gl,x, y);
}
}
}
5.Crea un algoritmo que genere la grfica de una lnea, calculando el punto medio.
1. Se capturan los dos extremos de la lnea y se almacena el extremo izquierdo en
(x0, y0).
2. Se carga (x0, y0) en el bufer de estructura y se traza el primer punto.
3. Se calculan las constantes Dy, Dx, 2Dy, 2Dy-2Dx, y se obtiene el valor inicia
l para el parmetro de decisin
como p0 = 2 Dy - Dx.
4. En cada xk a lo largo de la lnea, que inicia en k = 0, se efecta la prueba sigu
iente: si pk < 0, el
siguiente punto que se debe trazar es (xk+1, yk) y pk +1 = pk + 2 Dy.
De otro modo, el siguiente punto en trazarse es (xk+1, yk+1) y pk +1 = pk + 2
Dy - 2Dx.
5. Se repite el paso 4 otras Dx veces.
Donde Dy = x1-x0
Dx = y1-y0
pk = punto medio
6.Programe el Algoritmo de punto medio en OpenGL, dando desde el programa los pu
ntos inicial y final.
int xini, yini, xfin, yfin, pasos, contar;
int x, y, dx, dy, p, incE, incNE, stepx, stepy, xend;
public void paint(GL gl)
{
xini=50;
yini=50;
xfin=146;
yfin=138;
CorrePuntoMedio(gl,xini,yini,xfin,yfin);
puntoI(gl, xini, yini);
puntoI(gl, xfin, yfin);
}
void CorrePuntoMedio(GL gl,int x0, int y0, int x1, int y1){
dx = x1 - x0;
dy = y1 - y0;
p = 2*dy - dx;
incE = 2*dy;
incNE = 2*(dy-dx);
/* determinar que punto usar para empezar, cual para terminar */
if (x0 > x1) {
x = x1;
y = y1;
xend = x0;
}
else {
x = x0;
y = y0;
xend = x1;
}
/* se cicla hasta llegar al extremo de la lnea */
while (x <= xend)
{
punto(gl,x,y);
x = x + 1;
if (p <= 0)
p = p + incE;
else {
y = y + 1;
p = p + incNE;
}
}
}
7.Implemente el programa del circulo en OpenGL.
int xini, yini, xfin, yfin, pasos, contar;
public void paint(GL gl)
{
xini=100;
yini=80;
xfin=125;
yfin=80;
correCirculo(gl);
puntoI(gl, xini, yini);
puntoI(gl, xfin, yfin);
}
void correCirculo(GL g){
int x=0,y, p, r;
r = Math.abs(xini-xfin);
y=r;
p = 1-r;
while(x<=y){
punto(g,x+xini,y+yini);
punto(g,-x+xini,y+yini);
punto(g,y+xini,-x+yini);
punto(g,-y+xini,-x+yini);
punto(g,-x+xini,-y+yini);
punto(g,x+xini,-y+yini);
punto(g,-y+xini,x+yini);
punto(g,y+xini,x+yini);
if(p<0){
p = p + 2*x + 1;
x++;
} else {
p = p + 2*x + 1 - 2*(2*y-2);
x++;
y--;
}
}
}
8.Busque el algoritmo para generar elipses y progrmelo en Applet.
Algoritmo del punto medio para generar Elipses
1. Se capturan el radio rx, ry y el centro de la circunferencia (xc, yc) y se ob
tiene el primer punto de una elipse centrada en el origen como
(x0, y0) = (0, ry), donde 2 ry^2x = 0 y 2 rx^2y = 2 rx^2 ry
2. Se calcula el valor inicial del parmetro de decisin como p1_0 = ry^ 2 - rx^ 2 r
y + 1/4 rx^ 2
3. En cada posicin xk, en la regin 1, iniciando en k=0, se efecta la prueba siguien
te:
Si p1_k < 0, el siguiente punto a lo largo de la elipse centrada en (0,0) es
(x_(k+1), y_k) y p1_(k+1) = p1_(k + 2) ry^ 2x_(k+1) + ry^ 2.
De otro modo, el siguiente punto a lo largo de la circunferencia es
(x_(k+1), y_(k -1)) y p1_(k+1) = p1_(k + 2) ry^ 2 x_(k+1) + ry^ 2 - 2 rx^ 2 y_(k
+1)
donde x_(k+1) = x_(k + 1) y y_(k+1) = y_(k - 1).
4. Se evala el valor inicial del parmetro de decisin en la regin 2 utilizando el ult
imo punto (x0, y0) calculado
en la regin 1 como: . p2_0 = ry^ 2 (x_0+ 1/2)^ 2 + rx^ 2 (y_0 - 1)^ 2 - rx^ 2ry^
2
5. En cada posicin y_k, en la regin 2, iniciando en k=0, se efecta la prueba siguie
nte:
Si p2_k > 0, el siguiente punto a lo largo de la elipse centrada en (0,0) es
(x_k, y_(k-1)) y p2_(k+1) = p2_k - 2 rx^2y_(k+1) + rx^ 2.
De otro modo, el siguiente punto a lo largo de la circunferencia es
(x_(k+1), y_(k -1)) y p2_(k+1) = p2_k + 2 ry^ 2x_(k+1) - 2 rx^ 2 y_(k+1) + rx^ 2
donde x_(k+1) = x_k + 1 y y_(k+1) = y_(k - 1).
6. Se determinan puntos de simetra en los otros tres cuadrantes.
7. Se mueve cada posicin de pixel calculada (x,y) a la trayectoria elptica centrad
a en (xc,yc) y se traza los valores
de las coordenadas x = x + xc, y = y + yc.
8. Se repiten los pasos para la regin 1 hasta que 2 ry^ 2x >= 2 rx^ 2y.
package Graficacion;
import java.applet.Applet;
import java.awt.Button;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
public class elipseapplet extends Applet implements MouseListener,
ActionListener{
int xini, yini, xfin, yfin, pasos, contar,ry, rx;
boolean puntos, procesos;
Button proceso;
void cuadro(Graphics g, Color c){
int i;
g.setColor(c);
for(i=0;i<=250;i+=10){
g.drawLine(i, 0, i, 250);
g.drawLine(0, i, 250, i);
}
}
public void Elipse(Graphics g){
int x, y, p, px, py;
int rx2, ry2, tworx2, twory2;
ry2 = ry*ry;
rx2 = rx*rx;
twory2 = 2 * ry2;
tworx2 = 2 * rx2;
/* regin 1 */
x = 0;
y = ry;
dibujaPunto(g,x+xini,y+yini,Color.cyan);
dibujaPunto(g,-x+xini,y+yini,Color.red);
dibujaPunto(g,x+xini,-y+yini,Color.black);
dibujaPunto(g,-x+xini,-y+yini,Color.yellow);
p = (int) Math.round(ry2 - rx2*ry + (0.25*rx2));
px = 0;
py = tworx2*y;
while (px < py) { /* se cicla hasta trazar la regin 1 */
x = x + 1;
px = px + twory2;
if (p < 0)
p = p + ry2 + px;
else
{
y = y - 1;
py = py - tworx2;
p = p + ry2 + px - py;
}
dibujaPunto(g,x+xini,y+yini,Color.cyan);
dibujaPunto(g,-x+xini,y+yini,Color.red);
dibujaPunto(g,x+xini,-y+yini,Color.black);
dibujaPunto(g,-x+xini,-y+yini,Color.yellow);
}
/* regin 2 */
p = (int) Math.round(ry2*(x+0.5)*(x+0.5) + rx2*(y-1)*(y-1) - rx2*ry2);
px = 0;
py = tworx2*y;
while (y > 0) { /* se cicla hasta trazar la regin 2 */
y = y - 1;
py = py - tworx2;
if (p > 0)
p = p + rx2 - py;
else
{
x = x + 1;
px = px + twory2;
p = p + rx2 - py + px;
}
dibujaPunto(g,x+xini,y+yini,Color.cyan);
dibujaPunto(g,-x+xini,y+yini,Color.red);
dibujaPunto(g,x+xini,-y+yini,Color.black);
dibujaPunto(g,-x+xini,-y+yini,Color.yellow);
}
}
@Override
public void init() {
procesos = puntos = false;
xini = xfin = yini = yfin = contar = 0;
pasos = 0;
addMouseListener(this);
proceso = new Button("<Proceso>");
proceso.addActionListener(this);
proceso.setLocation(280, 120);
proceso.setSize(50, 13);
add(proceso);
}
void dibujaPunto(Graphics g,int x, int y, Color c){
g.setColor(c);
g.fillRect(x*10, y*10, 10, 10);
}
@Override
public void mouseClicked(MouseEvent me)
{ }
@Override
public void mousePressed(MouseEvent me) {
if (me.getX()<250 && me.getY()<250){
xini = me.getX()/10;
yini = me.getY()/10;
}
}
@Override
public void mouseReleased(MouseEvent me) {
if(me.getX()<250 && me.getY()<250){
xfin = me.getX()/10;
yfin = me.getY()/10;
puntos = true;
rx=Math.abs((int)xfin-xini);
//ry=(int)rx/2;
ry=Math.abs((int)yfin-yini);
repaint();
}
}
@Override
public void mouseEntered(MouseEvent me)
{ }
@Override
public void mouseExited(MouseEvent me)
{ }
@Override
public void paint(Graphics g){
if (puntos){
dibujaPunto(g, xini, yini, Color.blue);
dibujaPunto(g, xfin, yfin, Color.blue);
g.setColor(Color.black);
g.drawLine(xini*10+5, yini*10+5, xfin*10+5, yfin*10+5);
}
if (procesos){
Elipse(g);
}
cuadro(g,Color.black);
}
@Override
public void update(Graphics g){
paint(g);
}
@Override
public void actionPerformed(ActionEvent ae) {
if(ae.getSource()==proceso){
procesos = true;
repaint();
}
}
}
9.La elipse en OpenGL.
int xini, yini, xfin, yfin, pasos, contar,rx,ry;
public void paint(GL gl)
{
xini=10;
yini=10;
xfin=50;
yfin=21;
rx=80;
ry=30;
puntoI(gl, xini, yini);
puntoI(gl, xfin, yfin);
Elipse(gl);
}
public void Elipse(GL g){
int x, y, p, px, py;
int rx2, ry2, tworx2, twory2;
ry2 = ry*ry;
rx2 = rx*rx;
twory2 = 2 * ry2;
tworx2 = 2 * rx2;
/* regin 1 */
x = 0;
y = ry;
//PlotPoint(x,y);
punto(g,x+xini,y+yini);
punto(g,-x+xini,y+yini);
punto(g,x+xini,-y+yini);
punto(g,-x+xini,-y+yini);
/*dibujaPunto(g,x+xini,y+yini,Color.cyan);
dibujaPunto(g,-x+xini,y+yini,Color.red);
dibujaPunto(g,x+xini,-y+yini,Color.black);
dibujaPunto(g,-x+xini,-y+yini,Color.yellow);*/
p = (int)Math.round(ry2 - rx2*ry + 0.25*rx2);
px = 0;
py = tworx2*y;
while (px < py) { /* se cicla hasta trazar la regin 1 */
x = x + 1;
px = px + twory2;
if (p < 0)
p = p + ry2 + px;
else {
y = y - 1;
py = py - tworx2;
p = p + ry2 + px - py;
}
punto(g,x+xini,y+yini);
punto(g,-x+xini,y+yini);
punto(g,x+xini,-y+yini);
punto(g,-x+xini,-y+yini);
}
/* regin 2 */
p = (int)Math.round(ry2*(x+0.5)*(x+0.5) + rx2*(y-1)*(y-1) - rx2*ry2);
px = 0;
py = tworx2*y;
while (y > 0) { /* se cicla hasta trazar la regin 2 */
y = y - 1;
py = py - tworx2;
if (p > 0)
p = p + rx2 - py;
else {
x = x + 1;
px = px + twory2;
p = p + rx2 + py + px;
}
punto(g,x+xini,y+yini);
punto(g,-x+xini,y+yini);
punto(g,x+xini,-y+yini);
punto(g,-x+xini,-y+yini);
}
}
10.Programe, ya sea el de la parbola o la hiprbola en OpenGL.
int xini, yini, xfin, yfin, pasos, contar,p,bound;
public void paint(GL gl)
{
xini=10;
yini=10;
xfin=50;
yfin=21;
p=30;
bound=180;
puntoI(gl, xini, yini);
parabola(gl);
}
public void parabola(GL g){
int x,y,d;
int p2, p4;
p2 = 2*p;
p4 = 2*p2;
x = 0;
y = 0;
d = 1 - p;
//region 1
while(y < p && x<=bound){
punto(g,xini+x,yini+y);
punto(g,xini+x,yini-y);
if(d >= 0){
x++;
d = d - p2;
}
y++;
d = d + 2*y +1;
}
if(d == 1) d = 1 - p4;
else d = 1 - p2;
//region 2
while(x<=bound){
punto(g,xini+x,yini+y);
punto(g,xini+x,yini-y);
if(d <= 0){
y++;
d = d + 4*y;
}
x++;
d = d - p4;
}
}
Nota: Para los ejercicios con programas en OpenGl el programa base es el de DDA
para colocar el resto de los ejercicios solo se colocaron
solo las funciones y variables que cambian entre cada programa:
Los archivos consultados para la sol. fueron:
- http://galia.fc.uaslp.mx/%257Emedellin/Applets/LineasRectas/Recta.htm
- http://www.cannes.itam.mx/Alfredo/Espaniol/Cursos/Grafica/Linea.pdf
- http://galia.fc.uaslp.mx/~medellin/Applets/Circulos/circulos.htm