DIBUJOS VARIOS EN API JAVA 2D

1 // Demostración de algunas figuras de Java2D.

import java.awt.*;

import java.awt.geom.*;

import java.awt.image.*;

import javax.swing.*;

 

 public class Figuras extends JFrame {

 

    // establecer cadena de barra de título y dimensiones de la ventana

    publicFiguras()

    {

       super( "Dibujo de figuras en 2D" );

 

       setSize( 425, 160 );

       setVisible( true );

    }

 

    // dibujar figuras con la API Java2D

    public void paint( Graphics g )

    {

       super.paint( g );  // llamar al método paint de la superclase

 

       Graphics2D g2d = ( Graphics2D ) g;  // convertir g a Graphics2D

 

       // dibujar elipse 2D rellena con un gradiente azul-amarillo

       g2d.setPaint( new GradientPaint( 5, 30, Color.BLUE, 35, 100,

          Color.YELLOW, true ) ); 

       g2d.fill( new Ellipse2D.Double( 5, 30, 65, 100 ) );

 

       // dibujar rectángulo 2D en rojo

       g2d.setPaint(Color.RED );                 

       g2d.setStroke( new BasicStroke( 10.0f ) );

       g2d.draw( new Rectangle2D.Double( 80, 30, 65, 100 ) );

 

       // dibujar rectángulo 2D redondeado con fondo tamponado

       BufferedImagebuffImage = new BufferedImage( 10, 10,

          BufferedImage.TYPE_INT_RGB );

 

       Graphics2D gg = buffImage.createGraphics();

       gg.setColor(Color.YELLOW ); // dibujar en amarillo

       gg.fillRect( 0, 0, 10, 10 ); // dibujar un rectángulo relleno

       gg.setColor(Color.BLACK );  // dibujar en negro

       gg.drawRect( 1, 1, 6, 6 );   // dibujar un rectángulo

       gg.setColor(Color.BLUE );   // dibujar en azul

       gg.fillRect( 1, 1, 3, 3 );   // dibujar un rectángulo relleno

       gg.setColor(Color.RED );    // dibujar en rojo

       gg.fillRect( 4, 4, 3, 3 );   // dibujar un rectángulo relleno

 

       // pintar buffImage en el objeto JFrame

       g2d.setPaint( new TexturePaint( buffImage,

          new Rectangle( 10, 10 ) ) );

       g2d.fill( new RoundRectangle2D.Double( 155, 30, 75, 100, 50, 50 ) );

 

       // dibujar arco 2D en forma de pastel, en color blanco

       g2d.setPaint(Color.WHITE );

       g2d.setStroke( new BasicStroke( 6.0f ) );

       g2d.draw( new Arc2D.Double( 240, 30, 75, 100, 0, 270, Arc2D.PIE ) );

 

       // dibujar líneas 2D en verde y amarillo

       g2d.setPaint(Color.GREEN );

       g2d.draw( new Line2D.Double( 395, 30, 320, 150 ) );

 

       floatguiones[] = { 10 };

 

       g2d.setPaint(Color.YELLOW );   

       g2d.setStroke( new BasicStroke( 4, BasicStroke.CAP_ROUND,

          BasicStroke.JOIN_ROUND, 10, guiones, 0 ) );

       g2d.draw( new Line2D.Double( 320, 30, 395, 150 ) );

 

    } // fin del método paint

 

    // ejecutar la aplicación

    public static void main( String args[] )

    {

       Figuras aplicacion = new Figuras();

       aplicacion.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE );

    }

DIBUJAR UNA LINEA PUNTO POR PUNTO

    public void dibujarLinea(float x0, float y0, float x1, float y1, Color color, Graphics g)
    {
        float x, y, m;
        m =(y1-y0)/(x1-x0);
        x=x0;
        y=y0;
        while(x0<=x1)
        {
            g.setColor(color);
            g.drawRect((int) x, (int) y, 0, 0);
            x=x+1;
            y=y+m;
        }
   
    }

CLASE DIBUJO DE TUTORIAL

package tutorial;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;


public class Dibujo extends Canvas {
   
    public Dibujo(){
        setBackground(Color.black);
   
    }
   
    public void paint (Graphics g) {
       
        g.setColor(Color.GREEN);
        g.fillRect(20, 30, 150, 160);
       
        g.setColor(Color.blue);
        g.drawRect(250, 250, 80, 100);
       
        g.setColor(Color.CYAN);
        g.drawLine(60, 60, 300, 400);
       
       g.setColor(Color.ORANGE);
       g.drawArc(100, 100, 300, 300, 0, 90);
       
       g.drawOval(40, 40, 60, 60);
       
       g.drawRoundRect(90, 90, 200, 200, 10, 10);
     
       
        g.drawString("Hola Angelica",200,200);
       
        int [] x = {100,150,170,190,200};
        int [] y={120,280,200,250,60};
        g.setColor(Color.blue);
        g.fillPolygon(x, y, x.length);
       
       
       
    }
   
}

DIBUJAR UN ROMBO

public class Rombo {

    private int TAM;
    public String elItem = "*";
   
    public Rombo(int seconds) {
        TAM = seconds;
    }

   
    public void imprimir(int NOITEMS, int DIM){
   
    //calculos varios
    int f = (2*NOITEMS)-1;
    int espacios = DIM - f;
   
    //calcula el numero de espacios a imprimir para centrar los items
    if(espacios>0){
    int init = espacios/2;
    for(int x=1; x<=init; x++){ System.out.print(" "); }    
    }
    //imprime los items
    for(int j=1; j<=f; j++){ System.out.print(elItem); }
    }
   
   
    public void pintar(){
    System.out.println("Rombo: "+TAM);
    System.out.println(" ");
    //int ancho =  (TAM*2)-1;
    int lineas = (TAM*2)-1;
    int noitems = 0;
    int dim = lineas;
   
    for(int i = 1; i<=lineas; i++){
    //calcula el no de items a imprimir
    if(i<=TAM)
    noitems = i;
    else
    noitems = (lineas-(i-1));
   
    //imprime el numero de items    
    imprimir(noitems,dim);
   
    //crea una nueva linea
    System.out.print("\n");
    }
    }

    public static void main(String args[]) {
    int tam = 6;
        Rombo r = new Rombo(tam);
        r.elItem = "+";
        r.pintar();
    }


}

   
   
   

Dibujar Arcos

// Dibujo de arcos.
import java.awt.*;
import javax.swing.*;

public class DibujarArcos extends JFrame {

   // establecer cadena de barra de título y dimensiones de la ventana
   public DibujarArcos()
   {
      super( "Dibujo de arcos" );

      setSize( 300, 170 );
      setVisible( true );
   }

   // dibujar rectángulos y arcos
   public void paint( Graphics g )
   {
      super.paint( g );  // llamar al método paint de la superclase

      // empezar en 0 y extenderse hasta 360 grados
      g.setColor( Color.YELLOW );
      g.drawRect( 15, 35, 80, 80 );
      g.setColor( Color.RED );
      g.drawArc( 15, 35, 80, 80, 0, 360 );

      // empezar en 0 y extenderse hasta 110 grados
      g.setColor( Color.YELLOW );
      g.drawRect( 100, 35, 80, 80 );
      g.setColor( Color.RED );
      g.drawArc( 100, 35, 80, 80, 0, 110 );

      // empezar en 0 y extenderse hasta -270 grados
      g.setColor( Color.YELLOW );
      g.drawRect( 185, 35, 80, 80 );
      g.setColor( Color.RED );
      g.drawArc( 185, 35, 80, 80, 0, -270 );

      // empezar en 0 y extenderse hasta 360 grados
      g.fillArc( 15, 120, 80, 40, 0, 360 );

      // empezar en 0 y extenderse hasta -90 grados
      g.fillArc( 100, 120, 80, 40, 270, -90 );
               
      // empezar en 0 y extenderse hasta -270 grados
      g.fillArc( 185, 120, 80, 40, 0, -270 );

   } // fin del método paint

   // ejecutar la aplicación
   public static void main( String args[] )
   {
      DibujarArcos aplicacion = new DibujarArcos();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

} // fin de la clase DibujarArcos

ALGORITMOS BASICOS DE GRAFICACION

ALGORITMO DIBUJAR LINEA

ALGORITMO DIBUJAR LINEA

ALGORITMO DIBUJAR POLIGONO

ALGORITMO DIBUJAR POLIGONO REGULAR

BIBLIOGRAFIA

     ENLACES DE INTERÉS

Tutorial Básico de Java -   http://dl.dropboxusercontent.com/u/89227292/Manuales%20o%20Tutoriales/java.pdf

Algoritmos Básicos de Computación Gráfica http://dl.dropboxusercontent.com/u/89227292/Manuales%20o%20Tutoriales/Algoritmos%20Graficos.pdf

Libro Java a Tope -
http://www.lcc.uma.es/~galvez/ftp/libros/Java2D.pdf

 1.             James D. Foley, Andries Van Dam, Steven K. Feiner, John F. Hughes. Computer Graphics Principles and Practice (2nd. Ed. in C).

2. James D. Foley, Andries van Dam, Steven K. Feiner, and John F. Hughes. Introduction to Computer Graphics.
3. Dave Shreiner, Mason Woo, and Jackie Neider. OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 2.1 (6th Edition).
4. Randi J. Rost. OpenGL Shading Language (2nd Edition).
5. Thomas Akenine-Moller, Eric Haines and Naty Hoffman. Real-Time Rendering.
6. Hubert Nguyen,  GPU Gems 3.
7. Mark de Berg, Otfried Cheong, Marc van Kreveld and Mark Overmars. Computational Geometry: Algorithms and Applications.
8. Franco P. Preparata and Michael Ian Shamos. Computational Geometry: An Introduction.
9. Artículos varios que irán siendo citados oportunamente durante el transcurso del curso.