Tiempos violentos: Modelado de un cartucho de guerra

Una de las armas conocidas en Bolivia es el fusil Mauser, existen muchos modelos de esta arma regados por todo el terriorio nacional, la mayoria ya no sirven pero son un bonito souvenir que vienen desde nuestros abuelos y tarabuelos.

El que halla tenido la suerte de disparar una de estas armas sabe que es una experiencia única, en lo personal es el primer arma que dispare hace muchos años y aun recuerdo el fuerte culatazo que me dio, le di a todo menos al blanco :)

Si quieres aprender a modelar un cartucho de este fusil, en verdad muy sencillo, dale CLIC al siguiente enlace:

Modelar un Cartucho de guerra

continue reading

Java2D: Rotación de Figuras

Java2D nos permite realizar transformaciones en los objetos que creemos, como ser rotacion, traslación, escalado o una combinacion de todas ellas, ahora realizaremos una aplicacion en netbeans 6.0 para rotar una figura, como la que vemos en la imagen de arriba.

Importante:
En un eje de coordenadas, nosotros expresamos los angulos de derecha a izquierda en sentido contrario a las agujas del reloj, según me acuerdo de la escuela :)

Pero en Java2D, es al reves, los angulos van en el sentido de las agujas del reloj, cosa de locos no. Esto sucede porque java2D toma como eje imaginario la esquina superior izquierda

Proyecto:

1. Creamos un nuevo proyecto en netbeans, dale el nombre que quieras y añade una clase Interfaz, diseña esta interfaz como se ve en la imagen de abajo, no olvides colocar los nombres como se ven abajo

2. Ahora crea una nueva clase, la que llamaremos j2dPanel.java, esta clase se extendera de un JPanel, el codigo que debes ingresar es este:

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.geom.Line2D;
import java.awt.geom.QuadCurve2D;
import java.awt.geom.Rectangle2D;
import javax.swing.JPanel;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class j2dPanel extends JPanel{
    double centrox,centroy;
    double rotate; 
    /*constructor*/
    public j2dPanel(Dimension d){
     this.setPreferredSize(d);
     this.setSize(d);
     this.setVisible(true);
     //se obtiene las coordenadas del centro del jpanel
     this.centrox= this.size().width/2;
     this.centroy = this.size().height/2;
     //se inicializa la rotacion en o grados
     rotate = 0;
     this.repaint();     
    }
    
  @Override                   
  public void paintComponent(Graphics g){
    //se inicializa java2d
    super.paintComponent(g);      
    Graphics2D g2 = (Graphics2D)g;  
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    // se añade un color de fondo degrado
    g2.setPaint(new GradientPaint(0, 0, new Color(131,131,131), Float.valueOf(this.getSize().width), 0, new Color(188,194,236)));
    g2.fill(g2.getClip());       
    //se creo otro objeto AffineTransform para guardar los valores iniciales
    AffineTransform oldt = g2.getTransform();        
    //se aplica la rotacion y se traslada las coordenadas para que coincida con el centro del JPanel
    g2.transform(AffineTransform.getRotateInstance(Math.toRadians(rotate),this.centrox,this.centroy));               
    /************************************************************************/
    /* Una ves que se aplica la transformacion , todas las figuras se dibujaran siguiendo
     el angulo asignado en radianes y tomando como eje el centro del JPanel  */
    //grosor y color de pincel      
    g2.setColor(new Color(200,10,10));
    //se dibuja la figura, junto a una linea que nos servira para apreciar mejor la rotacion
    g2.setPaint(new GradientPaint((float) this.centrox-100, (float) this.centroy, new Color(200,0,25), (float) this.centrox+100, (float) this.centroy, new Color(0,96,27)));
    g2.fill(new Rectangle2D.Double( this.centrox-100, this.centroy-50, 200, 100));
    g2.fill(new Rectangle2D.Double( this.centrox-100, this.centroy-50, 100, 170));
    g2.setColor(new Color(0,0,200));
    g2.setStroke(new BasicStroke(4.0f)); 
    g2.draw(new Line2D.Double(this.centrox,this.centroy,this.centrox+100,this.centroy));
    //un poco de texto
    g2.setFont(new Font("Arial", Font.BOLD, 12));
    g2.drawString("  R=" + rotate+"°",(float) this.centrox+100 ,(float) this.centroy);
    /************************************************************************/
     
    //retornamos a los valores iniciales
    g2.setTransform(oldt);
    
    g2.setColor(new Color(0,0,0));
    g2.setFont(new Font("Arial", Font.PLAIN, 12));
    g2.drawString("Rotación (Grados) = " + rotate + "°", 10,25);
    g2.drawString("Rotación (Radianes) = " + Math.toRadians(rotate), 10,50);    
    g2.setFont(new Font("Arial", Font.BOLD, 12));
    g2.drawString("x' 180°", 10 ,(float) this.centroy-10);
    g2.drawString("x 0°", this.getSize().width-50 ,(float) this.centroy-10);
    g2.drawString("y 270°", (float) this.centrox+5 ,30);
    g2.drawString("y' 90°", (float) this.centrox+5 ,this.getSize().height-30);   
    // se dibuja una figura con forma de "flecha"
    g2.setStroke(new BasicStroke(2.0f));
    g2.draw(new QuadCurve2D.Double(this.centrox + 0, this.centroy + 50, this.centrox + 45,this.centroy + 45, this.centrox + 50, this.centroy + 0));                           
    g2.draw(new Line2D.Double(this.centrox + 0,this.centroy + 50,this.centrox + 10,this.centroy + 40));      
    g2.draw(new Line2D.Double(this.centrox + 0, this.centroy + 50,this.centrox + 14, this.centroy + 55));      
    
    //dibujamos unaas lineas que simularan el eje de coordenas X & Y
    g2.setStroke(new BasicStroke(1.0f));   
    g2.setColor(new Color(0,0,0));
    g2.draw(new Line2D.Double(this.centrox,0,this.centrox,this.centroy*2));      
    g2.draw(new Line2D.Double(0,this.centroy,this.centrox*2,this.centroy));      
    
    this.repaint();
  }
  
  //aplica la rotacion en grados
  public void setRotate(double r){
    this.rotate=r;
  }   
  //generamos un numero al azar de 0 a 360
  public void setRotateRandom(){
    this.rotate=(int)(Math.random()*360);
  }  
}

Lo que hacemos con esta clase es sobreescribir el metodo paintComponent() y luego utilizamos el objeto AffineTransform de Java2D para aplicar las transformacion, en este caso la ROTACION.

Para especificar el angulo de rotacion en Java2D se utilizan los radianes, asi que para ingresar un angulo, previamente debemos convertir esta utilizando Math.toRadians(). Al especificar la rotacion, tambien trasladamos el eje de coordendas al centro del JPanel (linea 49), si no hacemos esto, el punto de rotacion sera la esquina superior izquierda. Prueba cambiando estos valores y ve que pasa.

Cuando añadimos estas transformaciones al objeto Graphics2D (linea 53), todo los objetos que dibujemos despues se veran afectados, es por eso que antes guardamos el estado del objeto Graphics2D en otra variable oldt (linea 47) para que en cualquier momento volvamos a restaurar el estado original, como hacemos en la linea de codigo 70, para volver a dibujar el resto de los objetos.

3. Para implementar esta clase en la interfaz, hacemos lo siguiente:

Creamos una instancia a nuestro objeto j2dPanel,  inicializamos y añadimos al JFrame

01 public class Interfaz extends javax.swing.JFrame {
02     j2dPanel j2d;
03     /** Creates new form Interfaz */
04     public Interfaz() {
05         initComponents();
06         this.setTitle("AffineTransform: Rotación - by Mouse");
07         j2d = new j2dPanel(PANEL.getSize());
08         PANEL.add(j2d);
09         PANEL.repaint();
10     }

Para añadir los metodos a los jButton:

01     private void cmdRotar1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_cmdRotar1ActionPerformed
02          j2d.setRotate(Double.valueOf(txtRotate.getText()));           
03 }//GEN-LAST:event_cmdRotar1ActionPerformed
04 
05     private void cmdRotar2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_cmdRotar2ActionPerformed
06         j2d.setRotateRandom();
07 }//GEN-LAST:event_cmdRotar2ActionPerformed

Y listo, solo falta ejecutar el proyecto

Notece que los objetos que estan afectados con el AffineTransform giran completamente, figuras, texto, incluso el degradado.

El codigo fuente hecho en netbeans 6.0

La mejor forma de aprender es haciendo

continue reading

La clase QuadCurve2D "Curva de Bezier"

La clase QuadCurve2D de Java2D nos permite dibujar una curva basado en ecuaciones matematicas, esta curva tambien se la conoce con el nombre de Curva Cuadratica de Bezier.

Esta curva funciona de la siguiente manera: Se establecen dos puntos (P1 y P2) que establecen los extremos de un segmento curvo, y tambien se define un tercer punto (Punto de Control) el cual nos permite DEFORMAR la curva

La ecuacion con la cual se generan los diferentes puntos que forman la curva es:
 

 El valor de (t) va de 0 hasta 1, donde para un valor de 0 corresponde a las coordenadas de P1 y para un valor de 1, equivale a P2

Proyecto:

Porque se aprende mejor haciendo, dejo la teoria de las matematicas para su propia investigacion, lo que ahora haremos en este tutorial, sera construir una aplicacion en netbeans donde dibujaremos la curva QuadCurve2D, de dos maneras, una de ellas utilizando la clase propia de Java2D y la segunda donde haremos uso de la formula escrita mas arriba, asi podremos apreciar como java2d construye esta figura. Manos a la obra.

1. Crea un nuevo proyecto en Netbeans, Añade un nuevo JFrame: Interfaz y una clase nueva , llamala "miPaint.java", al JFrame interfaz, añadele los siguiente objetos, no te olvides de cambiarle los nombres como en la imagen:

2. A la clase miPaint.java añade el codigo:

01 import java.awt.BasicStroke;
02 import java.awt.Color;
03 import java.awt.Dimension;
04 import java.awt.Font;
05 import java.awt.Graphics;
06 import java.awt.Graphics2D;
07 import java.awt.geom.Line2D;
08 import java.awt.geom.Point2D;
09 import java.awt.geom.QuadCurve2D;
10 import java.text.NumberFormat;
11 import javax.swing.JOptionPane;
12 import javax.swing.JPanel;
13 /**
14  * @web http://jc-mouse.blogspot.com/
15  * @author Mouse
16  */
17 public class miPaint extends JPanel {
18     private Point2D Punto1;
19     private Point2D Punto2;
20     private Point2D Punto3;    
21     private Point2D Punto;
22     private boolean band=true;
23     float rango=0.01f;
24     
25     public miPaint(Dimension d){
26       this.setPreferredSize(d);
27       this.setSize(d);
28       this.setVisible(true);
29       this.repaint();      
30       //se crean las coordenas al azar
31       this.Punto1 = new Point2D.Double(getCoordenada(),getCoordenada());            
32       this.Punto2 = new Point2D.Double(getCoordenada(),getCoordenada());            
33       this.Punto3 = new Point2D.Double(getCoordenada(),getCoordenada()); 
34     }
35     //actualiza nuevas coordenadas a los Puntos
36     public void setPoint2D(String x1,String y1,String x2,String y2,String x3,String y3, boolean b){
37         this.Punto1 = new Point2D.Float(Float.valueOf(x1),Float.valueOf(y1));            
38         this.Punto2 = new Point2D.Float(Float.valueOf(x3),Float.valueOf(y3));            
39         this.Punto3 = new Point2D.Float(Float.valueOf(x2),Float.valueOf(y2));            
40         this.band=b;
41     }
42     
43   @Override                   
44   public void paintComponent(Graphics g){
45         super.paintComponent(g);      
46         Graphics2D g2 = (Graphics2D)g;    
47         //grosor de pincel
48         g2.setStroke(new BasicStroke(2.0f));   
49         //color de pincel
50         g2.setColor(new Color(0,0,200));
51         if(band){
52             Dibujar_QuadCurve2D(g2);
53         }else{
54             Dibujar_Bezier(g2);
55         }         
56         this.repaint();
57         Mostrar_Datos(g2);
58    }
59   
60   //dibuja la curva con la funcion de java2d QuadCurve2D
61   public void Dibujar_QuadCurve2D(Graphics2D g2){    
62     g2.draw(new QuadCurve2D.Double(Punto1.getX(), Punto1.getY(), Punto2.getX(), Punto2.getY(), 
63             Punto3.getX(), Punto3.getY()));                           
64   }
65   
66   //dibuja la curva con la funcion de la curva cuadratica de Bezier
67   //(1-t)^2*p1 + 2t(1-t)p2 + t^2*p3
68   public void Dibujar_Bezier(Graphics2D g2){
69         float f1;
70         float f2;        
71         float t=0;          
72         while (t<=1.0){  
73             //obtiene las coordenadas
74             f1 = (float) (((1-t)*(1-t) * Punto1.getX()) + 2 * t * (1 - t) * Punto2.getX() + (t * t) 
75                  * Punto3.getX()); 
76             f2 = (float) (((1-t)*(1-t) * Punto1.getY()) + 2 * t * (1 - t) * Punto2.getY() + (t * t) 
77                  * Punto3.getY());            
78             //crea un punto con esas coordenadas
79             Punto = new Point2D.Float(f1,f2);   
80             //dibuja el punto
81             g2.draw(new Line2D.Double(Punto.getX(),Punto.getY(),Punto.getX(),Punto.getY()));      
82             t = (float) (t + rango);    
83         }      
84         
85   }
86   
87   //
88   public void setRango(String x){
89       if((Float.valueOf(x)<=1)&&(Float.valueOf(x)>0.001)){
90          this.rango=Float.valueOf(x);  
91       }else{
92         JOptionPane.showMessageDialog(this,"Solo valores entre [0.001 y 1.0]");            
93       }
94     
95   }
96   /* metodos auxiliares */
97   
98   //muestra lascoordenas de los puntos P1,P2 Y P3
99   //dibuja las lineas que estos forman
100   private void Mostrar_Datos(Graphics2D g2){
101         g2.setStroke(new BasicStroke(1.0f));
102         g2.setColor(new Color(0,0,0));
103         g2.draw(new Line2D.Double(Punto1.getX(), Punto1.getY(), Punto2.getX(), Punto2.getY()));      
104         g2.draw(new Line2D.Double(Punto3.getX(), Punto3.getY(), Punto2.getX(), Punto2.getY()));      
105         dibuja_coordenada(g2,Punto1.getX(), Punto1.getY(),"Punto 1");
106         dibuja_coordenada(g2,Punto2.getX(), Punto2.getY(),"Punto de Control");
107         dibuja_coordenada(g2,Punto3.getX(), Punto3.getY(),"Punto 2");        
108   }
109   
110    //dibuja las coordenas dadas  un punto P1,P2   
111 private void dibuja_coordenada(Graphics2D g2,double x, double y,String t){       
112     NumberFormat mf = NumberFormat.getInstance(); 
113     mf.setMaximumFractionDigits(2); 
114     g2.setColor(new Color(255,0,0)); 
115     g2.setFont(new Font("Arial", Font.BOLD, 11));
116     g2.drawString(t + " ("+mf.format(x)+","+mf.format(y)+")",(float) (x+4),(float)  (y-10));       
117     g2.setStroke(new BasicStroke(4.5f));   
118     g2.draw(new Line2D.Double(x,y,x,y));      
119    } 
120 
121 //genera un valor al azar
122 private double getCoordenada(){ 
123     return ((Math.random()*350)+50);
124 }
125 
126      
127 }

Esta clase implementamos un nuevo JPanel al cual se le modificar su metodo paintComponent para que pueda dibujar las figuras con Java2D, asi tambien, solo para motivos ilustrativos, tambien se dibujaran las lineas entre P1-P3 y P2-P3 para que se pueda ver las lineas que estas forman  al trazar la curva bezier.

3. Para implementar esta clase en la interfaz, debemos hacer los siiguientes cambios:

01 public class interfaz extends javax.swing.JFrame {
02     miPaint paint;
03     /** Creates new form interfaz */
04     public interfaz() {
05         initComponents();
06         this.setTitle("JAVA2D - QuadCurve2D - [by Mouse]");
07         this.setLocationRelativeTo(null);  
08         paint = new miPaint(jPanel1.getSize());
09         jPanel1.add(paint);        
10     }
11 
12     private void bt_1ActionPerformed(java.awt.event.ActionEvent evt) {                                     
13         paint.setPoint2D(p1x.getText(), p1y.getText(), p2x.getText(), p2y.getText(), pcx.getText(), pcy.getText(),true);
14     }                                    
15 
16     private void bt_2ActionPerformed(java.awt.event.ActionEvent evt) {                                     
17         paint.setPoint2D(p1x.getText(), p1y.getText(), p2x.getText(), p2y.getText(), pcx.getText(), pcy.getText(),false);
18     }                                    
19 
20     private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
21             paint.setRango(f.getText());
22     }           

OJO: No copies y pegues, chekea donde va cada linea de codigo.

Con esto nuestra pequeña aplicacion estara lista para funcionar


Aqui dejo el codigo fuente en netbeans 6.0

continue reading

Introducción a Java2D

La API Java2D  nos permite tratar figuras, imagenes y texto en dos dimensiones, las posibilidades son casi ilimitadas, desde dibujar figuras basicas (cuadrados, lineas, texto), manipulacion de imagenes e incluso crear animaciones o presentaciones multimedia.

java.awt.Graphics2D: API de java que se extiene de AWT.Graphics

Comenzaremos con una aplicacion sencilla, para esto creamos un nuevo proyecto en Netbeans, "Java2d_Rectangulo" o el nombre que desees, despues añade un JFrame y para poder trabajar con java2d lo primero que debemos hacer es sobreescribir el metodo PAINT, el codigo que debes añadir al Jframe es:

01  @Override
02     public void paint (Graphics g) {
03         //creamos el objeto a dibujar
04         Rectangle2D rectangulo;
05         //pasamos el objeto Graphics a Graphics2D (upcasting)
06         Graphics2D g2 = (Graphics2D)g;
07         
08         /* Rectangulo simple con valores default de java2d */
09         rectangulo = new Rectangle2D.Float(50, 50, 300, 25);
10         g2.draw(rectangulo);
11         
12         /* Rectangulo con borde a color */
13         g2.setColor(Color.GREEN);
14         rectangulo = new Rectangle2D.Float(50, 100, 300, 25);
15         g2.draw(rectangulo);
16         
17         /* Rectangulo con borde a color y tipo de linea mas gruesa */
18         g2.setColor(Color.RED);
19         rectangulo = new Rectangle2D.Float(50, 150, 300, 25);       
20         Stroke pincel = new BasicStroke(5.0f, BasicStroke.CAP_ROUND,
21                             BasicStroke.JOIN_MITER);
22         g2.setStroke(pincel);        
23         g2.draw(rectangulo);
24         
25         /* Rectangulo con relleno  */        
26         g2.setColor(Color.DARK_GRAY);
27         rectangulo = new Rectangle2D.Float(50, 200, 300, 25);        
28         g2.fill(rectangulo);
29                 
30         /* Rectangulo con canal alfa */
31         // dibujamos un rectangulo de color amarillo y encima otro de color rojo
32         // sin transparencia        
33         g2.setColor(Color.YELLOW);
34         rectangulo = new Rectangle2D.Float(150, 240, 100, 50);       
35         g2.fill(rectangulo);
36         g2.setColor(Color.BLACK);
37         rectangulo = new Rectangle2D.Float(150, 240, 100, 50);       
38         g2.draw(rectangulo);
39         g2.setColor(Color.RED);
40         rectangulo = new Rectangle2D.Float(50, 250, 300, 25);                               
41         g2.fill(rectangulo);
42         
43         //aplicando transparencia
44         g2.setColor(Color.YELLOW);
45         rectangulo = new Rectangle2D.Float(150, 310, 100, 50);       
46         g2.fill(rectangulo);
47         g2.setColor(Color.BLACK);
48         rectangulo = new Rectangle2D.Float(150, 310, 100, 50);       
49         g2.draw(rectangulo);        
50         g2.setColor(Color.RED);
51         rectangulo = new Rectangle2D.Float(50, 320, 300, 25);                       
52         AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f);                     
53         g2.setComposite(ac);
54         g2.fill(rectangulo);
55         
56         /* por ultimo dibujamos un texto */
57         g2.setColor(Color.GREEN);
58         g2.setFont(new Font("Arial", Font.ITALIC, 24));
59         g2.drawString("Java2D by Mouse", 50, 440);
60 }

Las librerias que hacemos uso son:

01 import java.awt.*;
02 import java.awt.geom.*;
03 import java.awt.image.*;

Como se observa en el codigo, sobreescribimos el metodo PAINT con la instruccion @Override, despues pasamos el objeto Graphics a Graphics2d, y ya podemos comenzar a dibujar los objetos que deseemos.

La imagen de arriba, nos muestra el resultado que obtendremos, para esto hicimos uso del objeto Rectangle2D que nos permite dibujar rectangulos.

Parametros del objeto Rectangle2D(x1,y1,x2,y2)

x1,y1 : especifican la posicion de la esquina Sup. Izq.
x2,y2 : representan el ancho y largo


Tambien haremos uso de los metodos:

draw(): metodo que pinta la figura que se le pasa como parametro
fill(): metod igual al amterior, pero este pinta el relleno
setColor(): nos permite colocar un color a los graficoscon
Stroke : Estable un pincel con el cual pintaremos el contorno de los objetos.
AlphaComposite: Gestiona las transparencias en figuras, texto e imagenes.

drawString(): nos permite dibujar letras

estos objetos y metodos y muchos mas, los veremos en proximos tutoriales.

[actualizado]

Me olvide el codigo fuente ;)

aqui esta

continue reading