30 de noviembre de 2016

Rogelio Nieto Colorado

Programa de graficacin animada de una funcin seno en Java

En este programa se hace uso de la clase Java Graphics 2D que hereda las
propiedades de la clase Java Graphics y es una mejora directa de la misma, as
como se hace uso de la clase Swing que provee diferentes componentes de
utilidad que en este caso son JFrame y JPanel.
El programa calcula los valores en Y (coordenadas cartesianas) para la funcin
seno dado un ngulo que se calcula por iteracin en radianes, todo esto dentro
de la clase principal mientras hace uso de un arreglo dinmico por medio de un
ArrayList que es pblico. Los valores de la funcin seno son guardados en el
arreglo dinmico.
Mediante la clase animation se accesa al arreglo dinmico, se dibujan los ejes y
cada vez que se calcula un nuevo punto en la clase principal, redibuja todo los
puntos dentro del arreglo que contiene los valores en Y de la funcin
trigonomtrica. El programa est diseado para que las proporciones de la
onda, as como los ejes se mantengan aun cuando la ventana en ejecucin
cambie de tamao.
La estructura del programa fue probada satisfactoriamente en una Raspberry Pi
2 con Raspbian Pixel 1.0 quedando pendientes las siguientes mejoras
propuestas al programa:

El uso de hilos para la adquisicin/generacin de datos a graficar.

Mejorar la eficiencia del programa sobre las iteraciones.
Graficar los datos ledos de algn puerto de comunicacin de la
Raspberry (I2C, SPI, UART) haciendo uso de la librera PI4J vista durante
el curso.

Cdigo:

/*2016-11-14 <pi@raspberrypi>

* Este programa muestra una secuencia que va graficando una onda senoidal
* en el intervalo [0, 2pi]
*
14.11.2016
* REdefinir metodo paint y editar paintcomponent
15.11.2016
* Debugg
22.11.2016
* Add Circular Buffer

*/
import java.awt.*;
import javax.swing.*;
import java.util.ArrayList;
import java.util.List;

public class tarea8 {

private static final int SCALEFACTOR = 200;
//Resolucin
private static double s, rad;
//Vriables para calcular el seno y su angulo en rad
public static final int points=SCALEFACTOR*2;
//Puntos por periodo
public static ArrayList<Double> cArray = new ArrayList<Double>(); //Array List que guardar el
buffer de datos de forma ciclca

public static void main(String[] args) throws InterruptedException {

int i=0;
JFrame frame = new JFrame();
frame.setTitle("Sine Wave animation");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setBackground(Color.black);
frame.setSize(500, 200);
animation sine_animation = new animation();
//Se define una nueva clase animacin
frame.add(sine_animation);
//Se aade la calse al marco
frame.setVisible(true);
//Se hace visible el marco
while(true)
{
if(cArray.size()==400)cArray.remove(0);
//Si el tamao del array es igual al nmero mx. de puntos, elimina el primero (Reajustar tamao)
if(i<points){
//Mientras se esten calculando los numeros de [0 a 2pi]
rad=(Math.PI / SCALEFACTOR) * i;
//Se calcula el angulo en rad
s=-(Math.sin(rad));
cArray.add(s);
//Se almacena en el Array List
sine_animation.repaint();
//Se redibuja
i++;
//Pasa a la siguiente iteracin y siguiente angulo
Thread.sleep(20); //
//Pausa el hilo actual 20 ms
}
else{
//Si el nmero de puntos supera 2pi, reinicia
i=0;
}
}
}

class animation extends JPanel {

private int maxWidth;

// Ancho max de la ventana
private double hstep;
//Espaciado entre puntos normalizado al tamao de la ventana
private int maxHeight;
// Altura max de la ventan

private double sines = 0;

//
 private int t = 0;
//

void setPoint(double s1,int x1) {

//
sines= s1;
//
t = x1;
//
}
//

public void paintComponent( Graphics g ){

super.paintComponent( g );

maxWidth = getWidth();
maxHeight = getHeight();

this.setBackground( Color.BLACK );

g.setColor(Color.GREEN);
//Cuando se llama al metodo dibuja los ejes en la ventana
g.drawLine(0,maxHeight/2,maxWidth,maxHeight/2);
g.drawLine(maxWidth/4,(int) (maxHeight*0.48),maxWidth/4,(int) (maxHeight*0.52));
g.drawLine(maxWidth/2,(int) (maxHeight*0.48),maxWidth/2,(int) (maxHeight*0.52));
g.drawLine(3*maxWidth/4,(int) (maxHeight*0.48),3*maxWidth/4,(int) (maxHeight*0.52));
g.drawLine(maxWidth,(int) (maxHeight*0.48),maxWidth,(int) (maxHeight*0.52));
g.drawLine(0,0,0,maxHeight);
g.drawLine(0,(int)(maxHeight*0.03),10,(int)(maxHeight*0.03));
g.drawLine(0,(int)(maxHeight*0.97),10,(int)(maxHeight*0.97));
}

public void paint(Graphics g) {

//Se redefine el metodo paint
super.paint(g); //Cada vez que se llama, borra pantalla.
Graphics2D g2d = (Graphics2D) g;

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);

ArrayList<Double> Array=tarea8.cArray;

maxWidth = getWidth();
hstep = (double) maxWidth / (double) tarea8.points;
//normalizacin del espaciado entre puntos
maxHeight = getHeight();

g2d.setColor(Color.RED);

for(int i=0 ; i<Array.size() ; i++){

//Recorre todos los puntos del arreglo dinamico
int y = (int) (Array.get(i) * maxHeight / 2 * 0.95 + maxHeight / 2);
int x = (int) (i * hstep);
g2d.fillOval(x,y,3,3);
//Primitiva de Java Graphics 2D
}

}
Resultados