Programación

Dibujar y pintar en Java

Dibujar y pintar con paintComponent

El método paintComponent es el método utilizado por Java para dibujar y pintar los componentes de un panel o de una ventana con Swing. Este método también es posible llamarlo manualmente mediante el uso del método repaint() permitiendo realizar un redibujado o repintado en la pantalla. Además de esto, dispone de métodos que permiten dibujar o pintar líneas o figuras como pueden ser cuadrados, círculos, polígonos, etc...

Para poder implementarlo es necesario sobreescribirlo aportando los métodos y los datos necesarios para realizar el dibujado o pintado. El método paintComponent requiere de un argumento de tipo Graphics, que a su vez, debe ser convertido a tipo Graphics2D para poder realizar este dibujado.

Para entender mejor el funcionamiento, el siguiente código muestra un ejemplo de una clase llamada Dibujo que llama a la clase Draw() que es la encargada de incorporar los distintos métodos en el proceso de dibujado y/o pintado. 

  1. package dibujo;
  2. import javax.swing.JFrame;
  3. public class Dibujo extends JFrame {    
  4.     private Draw draw;
  5.     private int sizeX = 600, sizeY = 600 + 40;
  6.     
  7.     public Dibujo() {
  8.         this.setSize(sizeX,sizeY);
  9.         this.setDefaultCloseOperation(EXIT_ON_CLOSE);
  10.         //quitar margen de ventana
  11.         //this.setUndecorated(true);        
  12.         draw = new Draw();
  13.         draw.setBounds(0,0,sizeX,sizeY);
  14.         this.add(draw);        
  15.     }
  16.     
  17.     public static void main(String[] args) {
  18.         Dibujo dibujo= new Dibujo();
  19.         dibujo.setVisible(true);
  20.     }
  21. }

A continuación la clase Draw() implementando algunas de las distintas opciones para dibujar o pintar que permite Java mediante el método paintComponent() .

LÍNEAS

Para dibujar líneas solamente es necesario indicar las coordenadas (x,y) de inicio de línea y las coordenadas (x,y)de fin de línea. 

LÍNEAS con Line2D

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.geom.Line2D;
  6. import javax.swing.JPanel;
  7. public class Draw extends JPanel {
  8.     private Line2D.Float linea = new Line2D.Float(0, 0, 600, 600);
  9.     private Line2D.Float linea2 = new Line2D.Float(0,600,600,0);
  10.     @Override
  11.     public void paintComponent(Graphics g)
  12.     {
  13.         Graphics2D g2d = (Graphics2D) g;
  14.         g2d.setBackground(Color.yellow);
  15.         g2d.draw(linea);
  16.         g2d.draw(linea2);
  17.     }
  18. }

LÍNEAS con drawLine()

  1. @Override
  2. public void paintComponent(Graphics g)
  3. {
  4.     Graphics2D g2d = (Graphics2D) g;
  5.     g2d.drawLine(0, 600, 600, 0);
  6. }

ELIPSES

Según su definición la elipse es el lugar geométrico de los puntos del plano cuya suma de las distancias a dos puntos fijos, llamados focos es constante. De forma simple una elipse es una forma geométrica similar a un círculo pero que mantiene una forma ovalada. Para crear una elipse, de igual forma que la línea, es necesario indicar las coordenadas del inicio y del final, teniendo en cuenta que éstas se manejan como si un rectángulo se trazara sobre los puntos más alejados del centro de la elipse.

ELIPSE con Ellipse2D

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.geom.Ellipse2D;
  6. import javax.swing.JPanel;
  7. public class Draw extends JPanel {
  8.     private Ellipse2D.Float elipse = new Ellipse2D.Float(0,0,400,200);
  9.     @Override
  10.     public void paintComponent(Graphics g)
  11.     {
  12.         Graphics2D g2d = (Graphics2D) g;
  13.         g2d.setColor(Color.yellow);
  14.         g2d.draw(elipse);
  15.         g2d.setColor(Color.red);
  16.         g2d.fill(elipse);  
  17.     }
  18. }

ELIPSE con drawOval()

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import javax.swing.JPanel;
  6. public class Draw extends JPanel {    
  7.     @Override
  8.     public void paintComponent(Graphics g)
  9.     {
  10.         Graphics2D g2d = (Graphics2D) g;
  11.         g2d.setColor(Color.yellow);
  12.         g2d.drawOval(100, 100, 200, 400);
  13.         g2d.setColor(Color.red);
  14.         g2d.fillOval(100, 100, 200, 400);  
  15.     }
  16. }

CÍRCULOS 

Un círculo es una elipse con la particularidad adicional de que mantiene la misma distancia desde cualquier punto que delimita dicha elipse respecto a su radio. Por tanto de la misma forma que se crea una  elipse se crea un círculo, la única diferencia son las coordenadas dadas.

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.geom.Ellipse2D;
  6. import javax.swing.JPanel;
  7. public class Draw extends JPanel {
  8.     private Ellipse2D.Float elipse = new Ellipse2D.Float(0,0,400,400);
  9.     @Override
  10.     public void paintComponent(Graphics g)
  11.     {
  12.         Graphics2D g2d = (Graphics2D) g;
  13.         g2d.setColor(Color.yellow);
  14.         g2d.draw(elipse);    
  15.     }
  16. }

RECTÁNGULOS

Un rectángulo es una forma geométrica formada por cuatro ángulos de 90 grados y que la distancia de un lado debe ser la misma que la del lado opuesto.

RECTÁNGULOS con Rectangle2D()

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.geom.Rectangle2D;
  6. import javax.swing.JPanel;
  7. public class Draw extends JPanel {
  8.     private Rectangle2D.Float rectangulo = new Rectangle2D.Float(100,20,300,500);
  9.     @Override
  10.     public void paintComponent(Graphics g)
  11.     {
  12.         Graphics2D g2d = (Graphics2D) g;
  13.         g2d.setColor(Color.MAGENTA);
  14.         g2d.fill(rectangulo);
  15.         g2d.setColor(Color.BLUE);
  16.         g2d.draw(rectangulo);   
  17.     }
  18. }

RECTÁNGULOS con drawRect()

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import javax.swing.JPanel;
  6. public class Draw extends JPanel {
  7.     
  8.     @Override
  9.     public void paintComponent(Graphics g)
  10.     {
  11.         Graphics2D g2d = (Graphics2D) g;
  12.         g2d.setColor(Color.BLUE);
  13.         g2d.fillRect(0, 300, 300, 300);
  14.         g2d.setColor(Color.MAGENTA);
  15.         g2d.drawRect(100, 100, 300, 500);   
  16.     }
  17. }

CUADRADO

El cuadrado es un rectángulo con la característica añadida de que todos los lados son iguales.

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.geom.Rectangle2D;
  6. import javax.swing.JPanel;
  7. public class Draw extends JPanel {
  8.     private Rectangle2D.Float rectangulo = new Rectangle2D.Float(20,20,100,100);
  9.     @Override
  10.     public void paintComponent(Graphics g)
  11.     {
  12.         Graphics2D g2d = (Graphics2D) g;
  13.         g2d.setColor(Color.MAGENTA);
  14.         g2d.fill(rectangulo);
  15.         g2d.setColor(Color.BLUE);
  16.         g2d.draw(rectangulo);   
  17.     }
  18. }

POLÍGONOS

Para dibujar o pintar polígonos con paintComponent es necesario indicar los puntos de intersección mediante dos arrays, un array que representa el eje de coordenadas x y otro array el eje de coordenadas y.  El orden de los elementos de cada array deben ser coincidentes y también corresponderá al recorrido que realizará el trazo en proceso de dibujado.

TRIÁNGULO con Polygon

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.Polygon;
  6. import javax.swing.JPanel;
  7. public class Draw extends JPanel {
  8.     private int x[] = {300,0,600,300};
  9.     private int y[] = {0,600,600,0};
  10.     private Polygon triangulo = new Polygon(x2,y2,3)
  11.     @Override
  12.     public void paintComponent(Graphics g)
  13.     {
  14.         
  15.         Graphics2D g2d = (Graphics2D) g;
  17.         g2d.setColor(Color.red);
  18.         g2d.draw(triangulo);
  19.     }
  20. }

TRIÁNGULO con drawPolygon

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import javax.swing.JPanel;
  6. public class Draw extends JPanel {    
  7.     @Override
  8.     public void paintComponent(Graphics g)
  9.     {        
  10.         Graphics2D g2d = (Graphics2D) g;
  11.         int x[] = {300,0,600};
  12.         int y[] = {0, 600,600};
  13.         g2d.fillPolygon(x,y,3);
  14.         g2d.setColor(Color.red);
  15.         g2d.drawPolygon(x,y,3);
  16.     }
  17. }

TRIÁNGULO con drawPolyline

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import javax.swing.JPanel;
  6. public class Draw extends JPanel {    
  7.     @Override
  8.     public void paintComponent(Graphics g)
  9.     {        
  10.         Graphics2D g2d = (Graphics2D) g;
  11.         int x[] = {300,0,600,300};
  12.         int y[] = {0, 600,600,0};
  13.         g2d.fillPolygon(x,y,4);
  14.         g2d.setColor(Color.red);
  15.         g2d.drawPolygon(x,y,4);
  16.     }
  17. }

La diferencia entre drawPolygon y drawPolyline es que drawPolygon incluye automáticamente una última coordenada igual a la primera para cerrar el polígono mientras que drawPolyline permite trabajar con polígonos abiertos y, por tanto, es necesario incluir en el array la coordenada de cierre.

ESTRELLAS

ESTRELLA (5 puntas)

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import javax.swing.JPanel;
  6. public class Draw extends JPanel {    
  7.     @Override
  8.     public void paintComponent(Graphics g)
  9.     {        
  10.         Graphics2D g2d = (Graphics2D) g;
  11.         int x[] = {300,0,600,0,450,300};
  12.         int y[] = {0,600,200,200,600,0};
  13.         g2d.fillPolygon(x,y,5);
  14.         g2d.setColor(Color.red);
  15.         g2d.drawPolygon(x,y,5);
  16.     }
  17. }

ESTRELLA (6 puntas)

  1. package dibujo;
  2. import java.awt.Color;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import javax.swing.JPanel;
  6. public class Draw extends JPanel {    
  7.     @Override
  8.     public void paintComponent(Graphics g)
  9.     {        
  10.         Graphics2D g2d = (Graphics2D) g;
  11.         int x[] = {300,0, 600};
  12.         int y[] = {0,450,450};
  13.         g2d.fillPolygon(x,y,3);
  14.         int x2[] = {0,300,600};
  15.         int y2[] = {150,600,150};
  16.         g2d.fillPolygon(x2,y2,3);
  17.     }
  18. }


Comentarios: 0

Para poder comentar es necesario iniciar sesión


Este dominio utiliza cookies de terceros para crear estadísticas y publicidad personalizada. Si continúa navegando está aceptando su uso