Laboratorio 014: Relleno poligonal

publicado a la‎(s)‎ 5 jul. 2012 5:15 por Hernan Nina Hanco   [ actualizado el 3 jun. 2014 16:03 ]

I) Objetivo

  • Implementar algoritmos de relleno poligonal descritos en la teoría de la asignatura.

II) Marco conceptual

    Ver Guía de Computación Gráfica


III) Prácticas

1) Dibujar un polígono utilizando polilineas cerradas.

Clase Renderer_RellenoPoligonal

/*
 * Creado el 23 de mayo, 2012 por Hernán Nina Hanco
 *
 * Este trabajo es parte del proyecto CG1, que corresponde a la 
 * implementación de algoritmos de Dibujo de graficas.
 * 
 * Universidad Nacional de San Antonio Abad del Cusco
 * Carrera Profesional de Ingeniería Informática y de Sistemas
 * Asignatura: Computación Gráfica I
 */
package geometrias.rellenoareas;
/*
 * Dibujo de líneas con pendiente -1<m<1
 * @author Hernan Nina Hanco 
 */

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.media.opengl.*;

public class Renderer_RellenoPoligonal implements GLEventListener {

    static final Logger logger = Logger.getLogger("BasicLoggingExample");
    protected GL2 gl;
    /*
     * Inicializar graficador OpenGL
     */

    @Override
    public void init(GLAutoDrawable gLDrawable) {
        logger.log(Level.INFO, "método - init");
        // Provee un objeto que enlaza las APIs del OpenGL
        // Que se encargara de realizar las instrucciones de dibujos 
        gl = gLDrawable.getGL().getGL2();

        // Color de fondo del GLCanvas
        gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        gl.glClear(GL2.GL_COLOR_BUFFER_BIT);

        // definir el color del pincel
        gl.glColor3f(1.0f, 0.0f, 0.0f);

    }
    /*
     * Método para actualizar el dibujo cuando,
     * se modifica el tamaño de la ventana.
     */

    @Override
    public void reshape(GLAutoDrawable glad, int x, int y, int width,
            int height) {
        logger.log(Level.INFO, "Reshape");
        // 7. Especificar el área de dibujo (frame) utilizamos coordenadas
        gl.glMatrixMode(GL2.GL_PROJECTION);
        gl.glLoadIdentity();
        gl.glOrtho(-width, width, -height, height, -1.0, 1.0);
    }

    @Override
    public void dispose(GLAutoDrawable glad) {
        // no implementado
    }

    /*
     * Inicializar y presentar el dibujo de OpenGL
     */
    @Override
    public void display(GLAutoDrawable drawable) {
        // Establecer el tamaño y color del punto     
        gl.glPointSize(1);
        gl.glColor3f(0.0f, 0.0f, 1.0f);

        // Dibujar polilinea cerrada
        List<Punto> vertices = new ArrayList<Punto>();
        vertices.add(new Punto(0, 0, 0));
        vertices.add(new Punto(100, 0, 0));
        vertices.add(new Punto(200, 100, 0));
        vertices.add(new Punto(300, 0, 0));
        vertices.add(new Punto(300, 300, 0));
        vertices.add(new Punto(0, 300, 0));
        dibujarPolilineasCerrada(vertices);
        // Identificar poligono concavo
        // identificarPoligonoConcavo();
    }
    /*
     * Dibujar un poligono utilizando polilinea cerrada
     */
    private void dibujarPolilineasCerrada(List<Punto> vertices) {
        int numeroVertices = vertices.size();
        for (int i = 0; i < numeroVertices - 1; i++) {
            int x0 = vertices.get(i).getX();
            int y0 = vertices.get(i).getY();
            int xn = vertices.get(i + 1).getX();
            int yn = vertices.get(i + 1).getY();
            lineaBresenham(x0, y0, xn, yn);
        }
        // cerrar la figura
        int x0 = vertices.get(numeroVertices - 1).getX();
        int y0 = vertices.get(numeroVertices - 1).getY();
        int xn = vertices.get(0).getX();
        int yn = vertices.get(0).getY();
        lineaBresenham(x0, y0, xn, yn);
    }
    /*
     * Dibujar línea arbitraria con metodo bresenham 
     */
    public void lineaBresenham(int x0, int y0, int xn, int yn) {
        int dx, dy, incrE, incrNE, d, x, y, flag = 0;

        if (xn < x0) {
            //intercambiar(x0,xn);
            int temp = x0;
            x0 = xn;
            xn = temp;

            //intercambiar(y0,yn);
            temp = y0;
            y0 = yn;
            yn = temp;
        }
        if (yn < y0) {
            y0 = -y0;
            yn = -yn;
            flag = 10;
        }

        dy = yn - y0;
        dx = xn - x0;

        if (dx < dy) {
            //intercambiar(x0,y0);
            int temp = x0;
            x0 = y0;
            y0 = temp;

            //intercambiar(xn,yn);
            temp = xn;
            xn = yn;
            yn = temp;

            //intercambiar(dy,dx);
            temp = dy;
            dy = dx;
            dx = temp;
            flag++;
        }

        x = x0;
        y = y0;
        d = 2 * dy - dx;
        incrE = 2 * dy;
        incrNE = 2 * (dy - dx);

        while (x < xn + 1) {
            escribirPixel(x, y, flag); /* Dibujar punto */
            x++; /* siguiente pixel */
            if (d <= 0) {
                d += incrE;
            } else {
                y++;
                d += incrNE;
            }
        }
    }

    void escribirPixel(int x, int y, int flag) {
        int xf = x, yf = y;
        if (flag == 1) {
            xf = y;
            yf = x;
        } else if (flag == 10) {
            xf = x;
            yf = -y;
        } else if (flag == 11) {
            xf = y;
            yf = -x;
        }
        dibujarPunto(xf, yf);
    }

    /*
     * Dibujar un punto 
     */
    protected void dibujarPunto(int x, int y) {
        gl.glPointSize(2);
        gl.glBegin(GL.GL_POINTS);
        gl.glVertex2i(x, y);
        gl.glEnd();
    }
}

Resultado:

IV) Tarea
1) Implementar un método para Identificar si el polígono es cóncavo o convexo. Además que pueda eliminar polígonos degenerados.
2) Si en caso fuese el polígono cóncavo dividir el mismo en polígonos convexos. Desarrolle un método para representar gráficamente la división 
3) Una vez que se identifiquen los polígonos convexos, implementar el método para dividirlo en triángulos. Muestre gráficamente el resultado
4) Implementar los métodos necesarios para las Pruebas dentro-fuera, para determinar el interior y exterior de una figura plana compleja. 
Comments