ALGUNOS EJEMPLOS SOBRE CLIPPING, FIGURAS Y TEXTO

 

TRABAJANDO CON CLIPPING

public void paint (Graphics g) {

        Graphics2D g2 = (Graphics2D)g;   

        // Primera parte del ejemplo

        int ancho = this.getSize().width;

        int largo = this.getSize().height;

        Ellipse2D e = new Ellipse2D.Float ( ancho/4.0f, largo/4.0f,

                              ancho/2.0f, largo/2.0f);

        g2.setClip(e);

        g2.setColor(Color.cyan);

        g2.fill(new Rectangle2D.Float(0.0f,0.0f,ancho,largo));

       

//Segunda parte del ejemplo

        Rectangle2D r2 = new Rectangle2D.Float( ancho/4.0f+10.0f, largo/4.0f+10.0f,

ancho/2.0f-20.0f, largo/2.0f-20.0f);

        g2.clip(r2);   

        g2.setColor(Color.white);

        g2.fill(new Rectangle2D.Float(0.0f,0.0f,ancho,largo));

}

COMPOSICIONES

public void paint (Graphics g) {

    Graphics2D g2 = (Graphics2D)g;

    Dimension d = getSize();

    int w = d.width;

    int h = d.height;

    // Crea una BufferedImage.

    BufferedImage buffImg = new BufferedImage(w, h,

BufferedImage.TYPE_INT_ARGB);

    Graphics2D gbi = buffImg.createGraphics();

      // Dibujo de un cuadrado rojo

        gbi.setColor(Color.red);

Rectangle2D r1 = new Rectangle2D.Float(150.0f, 50.0f, 100.0f, 100.0f);

        gbi.fill(r1);

    AlphaComposite ac;

    // Dibujo de un rectángulo verde encima

        ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER);

        gbi.setColor(Color.green);

        gbi.setComposite(ac);

        Rectangle2D r2 = new Rectangle2D.Float(150.0f, 100.0f, 150.0f, 100.0f);

        gbi.fill(r2);

      // Dibujo de un cuadrado magenta con preferencia de lo que hay debajo

        ac = AlphaComposite.getInstance(AlphaComposite.DST_OVER);

        gbi.setColor(Color.magenta);

        gbi.setComposite(ac);

        Rectangle2D r3 = new Rectangle2D.Float(100.0f, 100.0f, 100.0f, 100.0f);

        gbi.fill(r3);

      // Dibujo de un cuadrado amarillo que modifica sólo sobre lo que se superpone

        ac = AlphaComposite.getInstance(AlphaComposite.DST_IN, 0.15f);

        gbi.setColor(Color.yellow);

        gbi.setComposite(ac);

        Rectangle2D r4 = new Rectangle2D.Float(150.0f, 150.0f, 100.0f, 100.0f);

        gbi.fill(r4);

    g2.drawImage(buffImg, null, 0, 0);

}

DIBUJANDO CON GENERALPATH

public void paint (Graphics g) {

Graphics2D g2 = (Graphics2D)g;

// Creación del GeneralPath

g2.setColor(Color.green);

GeneralPath gp = new GeneralPath();

gp.moveTo(50.0f,50.0f);

gp.lineTo(100.0f,50.0f);

gp.curveTo(120.0f,30.0f,120.0f,100.0f,180.0f,125.0f);

gp.lineTo(50.0f,150.0f);

gp.closePath();

// Relleno y contorno

g2.fill(gp);

g2.setColor(Color.blue);

g2.draw(gp);

}

DIBUJAR TEXTO

public void paint (Graphics g) {

        super.paint(g);

        Graphics2D g2 = (Graphics2D)g;

        g2.setColor(Color.blue);

        g2.setFont(new Font("Arial", Font.ITALIC, 24));

g2.drawString("Lex Flavia Malacitana", 20, 60);

}

  

TEXTO CON TEXTLAYOUT

public void paint (Graphics g) {

        super.paint(g);

        Graphics2D g2 = (Graphics2D)g;      

FontRenderContext frc = g2.getFontRenderContext();

Font f = new Font("Arial", Font.ITALIC, 24);

TextLayout tl = new TextLayout("Lex Flavia Malacitana", f, frc);

g2.setColor(Color.red);

tl.draw(g2, 20, 60);

}

MAS COMPLETO

public void paint(Graphics g) {

Graphics2D g2 = (Graphics2D)g;

FontRenderContext frc = g2.getFontRenderContext();

Dimension tamaño = getSize();

TextLayout tl;

Font f;

f = new Font("Arial", Font.ITALIC, 24);

tl = new TextLayout("Tamaño 24 Arial Cursiva", f, frc);

g2.setColor(Color.pink);

tl.draw(g2, (float)(tamaño.width - tl.getBounds().getWidth())/2,

tamaño.height/2.0f);

f = f.deriveFont(Font.BOLD, 16);

tl = new TextLayout("Tamaño 16 Arial Negrita", f, frc);

g2.setColor(Color.red);

tl.draw(g2, (float)(tamaño.width - tl.getBounds().getWidth())/2,

tamaño.height/3.5f);

f = new Font("Times New Roman", Font.PLAIN, 20);

tl = new TextLayout("Tamaño 20 Times New Roman Normal", f, frc);

g2.setColor(Color.orange);

tl.draw(g2, (float)(tamaño.width - tl.getBounds().getWidth())/2,

tamaño.height/1.5f);

}

REGLAS DE COMPOSICIÓN Y EJEMPLO

TRANSFORMACIONES

ROTACION

ESCALA

DISTORSION

CURVAS

import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;

public class CubicCurve2D1 extends JFrame {
  private CubicCurve2D Shape1;
  private CubicCurve2D Shape2;
  private float X1;
  private float Y1;
  private float X2;
  private float Y2;
  private float CX1;
  private float CY1;
  private float CX2;
  private float CY2;
  private double DX1;
  private double DY1;
  private double DX2;
  private double DY2;
  private double DCX1;
  private double DCY1;
  private double DCX2;
  private double DCY2;

  public CubicCurve2D1 () {
    X1 = 10.F;
    Y1 = 20.F;
    X2 = 150.F;
    Y2 = 130.F;
    CX1 = 20.F;
    CY1 = 90.F;
    CX2 = 140.F;
    CY2 = 100.F;
    DX1 = 160.;
    DY1 = 20.;
    DX2 = 230.;
    DY2 = 40.;
    DCX1 = 160.;
    DCY1 = 120.;
    DCX2 = 240.;
    DCY2 = 90.;
    Shape1 = new CubicCurve2D.Float (X1, Y1, CX1, CY1, CX2, CY2, X2, Y2);
    Shape2 = new CubicCurve2D.Double ();
    Shape2.setCurve (DX1, DY1, DCX1, DCY1, DCX2, DCY2, DX2, DY2);
  }

  public void paint (Graphics g) {
    Graphics2D g2D;

    g2D = (Graphics2D) g;

    g2D.setColor (Color.cyan);
    g2D.drawLine ((int)X1, (int)Y1, (int)CX1, (int)CY1);
    g2D.drawLine ((int)X2, (int)Y2, (int)CX2, (int)CY2);
    g2D.drawLine ((int)DX1, (int)DY1, (int)DCX1, (int)DCY1);
    g2D.drawLine ((int)DX2, (int)DY2, (int)DCX2, (int)DCY2);

    g2D.setColor (Color.black);
    g2D.draw (Shape1);
    g2D.draw (Shape2);
  }

}

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.

CONTENIDO PROGRAMATICO

1)    Evolución de la computación gráfica

2)   Tipos de graficación computacional

2.1 Gráficos ráster

2.2 Gráfico vectorial

3) El hardware y el software para computación gráfica

3.1 Dispositivos de vectores

3.2 Dispositivos de ráster

3.3 Hardware gráfico para monitores – la tarjeta de video

3.4 Dispositivos de entrada

3.5 Software de graficación

4) Sistema de coordenadas

5) Introducción a la teoría del color

5.1 Descripción formal del color como fenómeno físico

5.2 Modelos de color

5.3 Representación del color en computación gráfica

5.4 Paletas estáticas y dinámicas

 6) Algoritmos básicos

6.1 Especificación de una discretización

6.2 Métodos de discretización

6.3 Segmentos de recta

7) Llenado de áreas

8.)Transformaciones

8.1 Breve repaso sobre matrices

8.2 Cambios de escala

8.3 Rotación                  

8.4 Coordenadas homogéneas y traslación

8.5 Rotación alrededor de un punto cualquiera

8.6 Otras transformaciones 80 Segmentos de rectas por Bressenham

8.7. Discretización de circunferencias

8.8 Dibujo de polígonos

      Polígonos irregulares

      Polígonos regulares 

9) API 2D de Java

9.1 Características generales del API 2D de Java

 Mejoras de gráficos, texto e imágenes

 Modelo de Renderizado

 Métodos de renderizado de Graphics2D

 Sistema de coordenadas

 Fuentes

 Imágenes

 Rellenos y Filetes

 Composiciones (composites)

 Los paquetes del API 2D de Java

9.2. La clase Graphics

 Métodos generales de la clase Graphics

Obtener un contexto gráfico

9.3 Figuras básicas en Java 2D (Shape)

 Formas Rectangulares

 GeneralPath

 QuadCurve2D y CubicCurve2D

 Áreas

9.4 Texto y Fuentes

9.5 Imágenes

El modelo de imágenes de modo inmediato y el BufferedImage 1.5.2 Filtrado de un BufferedImage

Uso de un BufferedImage para Doble Búfer

10.  API 3D de Java

10.1 Lo básico de Java 3D

            Instalación del paquete

10.2 Empezar con Java 3D

Construir un Escenario Gráfico

Árbol de Clases de Alto Nivel del API Java 3D

 Receta para Escribir Programas Java 3D

 Alguna Terminología Java 3D

10.3 Un Ejemplo de la aplicación de la receta

2.3.4 Clases Java 3D Usadas en HelloJava

10.4 Rotación de objetos

Combinación de transformaciones

Capacidades y Rendimiento

10.5 Añadir Comportamiento de Animación

Ejemplo de Comportamiento: HelloJava3Dc

Clases que intervienen para programar el comportamiento de

animación

10.6 Ejemplo de combinación de Transformación y Comportamiento:

            HelloJava