Java - relleno de poligonos

// aunque tarde pero apenas pude te trate de responder espero sirva a las otras 3300 personas que lo buscaban

// aquí coloco la web donde lo saque:

// http://hanconina.nubeuniversitaria.com/unsaac/computacion-grafica-i/laboratorio-de-computacion-grafica-i/laboratorio4rellenopoligonal

/*

 * 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();

    }

}