Este ejemplo consiste en que al pulsar un jButton se crea una imagen aleatoria cualquiera. Normalmente las imagenes que aparecen no tienen sentido, pero de hecho si Java tuviera una aleatoriedad absoluta, tarde o temprano acabarias apareciendo en una de estas imagenes. Y esque en la aleatoriedad esta el TODO. Por poner un ejemplo, para calcular la probabilidad de que aparezca "La Mona Lisa":
P(Mona Lisa) = 1 / {(Numero de Colores RBG)^(Tamaño jPanel)}
P(Mona Lisa) = 1 / { (255 x 255 x 255)^(375 x 250) }
P(Mona Lisa) = 3.75 x 10^(-676840)
Para empezar se crea un nuevo proyecto y en modo de diseño se agrega un jButton y un jPanel.
Codigo 1 (Principal.java):
package imagenesAleatorias;
public class Principal extends javax.swing.JFrame {
public Principal() {
initComponents();
this.setLocationRelativeTo(null); //Centrar pantalla
}
private void initComponents() { ... }//Codigo generado automáticamente
private void jButtonIniciarActionPerformed(java.awt.event.ActionEvent evt){
Dibujo.Dibujar(jPanel1.getGraphics(),
jPanel1.getWidth(),
jPanel1.getHeight());
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Principal().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButtonIniciar;
private javax.swing.JPanel jPanel1;
// End of variables declaration
}
Codigo 2 (Dibujo.java):
package imagenesAleatorias;
import java.awt.Color;
import java.awt.Graphics;
public class Dibujo {
public static void Dibujar(Graphics g, int width, int height) {
for (int i = 0; i < width; i++) {
for (int j = 0; j < height; j++) {
g.setColor(new Color(
(float) Math.random(),
(float) Math.random(),
(float) Math.random()));
g.fillRect(i, j, 1, 1); //dibuja pixel
}
}
}
}
Resultado:
Se crea un nuevo proyecto en Netbeans y en vista de diseño se agrega un jButton y un jPanel.
Codigo 1 (Principal.java):
package graficos1;
public class Principal extends javax.swing.JFrame {
public Principal() {
initComponents();
this.setLocationRelativeTo(null); //Centrar pantalla
}
@SuppressWarnings("unchecked")
private void initComponents() {...}
private void jButtonIniciarMouseClicked(java.awt.event.MouseEvent evt) {
Dibujo.Dibujar(jPanel1.getGraphics(), jPanel1.getWidth(), jPanel1.getHeight());
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Principal().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButtonIniciar;
private javax.swing.JPanel jPanel1;
// End of variables declaration
}
Codigo 2 (Dibujo.java):
package graficos1;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
public class Dibujo {
public static void Dibujar(Graphics g, int width, int height) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setColor(Color.BLUE);
int pasos = 25000, pos;
int w = width / 2;
int h = height / 2;
for (int i = 0; i < pasos; i++) {
pos = (int) Math.floor(Math.random() * 8 + 1);
switch (pos) {
case 1:
w--;
h++;
break;
case 2:
h++;
break;
case 3:
w++;
h++;
break;
case 4:
w++;
break;
case 5:
w++;
h--;
break;
case 6:
h--;
break;
case 7:
w--;
h--;
break;
case 8:
w--;
break;
}
//Dibuja un punto
g2.fillOval(w, h, 1, 1);
//Control laterales
w = (w > width) ? 1 : w;
w = (w < 1) ? width : w;
h = (h > height) ? 1 : h;
h = (h < 1) ? height : h;
}
}
}
Resultado:
Esta vez vamos a ver como funciona un sistema neuronal teniendo los pesos ya calibrados especificamente para la resolución de puertas lógicas XOR. El funcionamiento es el siguiente:
Voy a utilizar la notación bipolar(1,-1), que es la más usada en las redes neuronales artificiales por varias razones de peso y es que tiene un rango mayor, es más eficiente y más preciso que la notación binaria(0,1). Para la resolución del problema he elegido el Perceptrón Multicapa siguiente:
He puesto dos neuronas en la capa oculta siguiendo una regla que suele dar buenos resultados que es la de multiplicar el número de entradas por el número de neuronas de salida, y así obtenemos el número de neuronas a poner en la capa central (llamada oculta):
H = N * M
H = 2 * 1
H = 2
N = Número de Entradas (2)
M = Número de Neuronas de Salida (1)
H = Número de Neuronas de la Capa Oculta.
Y un último detalle es la nomenclatura que suele utilizarse para identificar los pesos de una red neuronal:
En el ejemplo el peso W21 está ubicado entre la primera entrada (x1) y la neurona 2.
Codigo:
//Perceptrón multicapa: Puerta Lógica XOR
package perceptronMultiCapa;
import java.util.Scanner;
public class RNeuronaXor {
public static void main(String[] args) {
//Introducción manual de las entradas x1, x2.
System.out.println("Introduce Entrada X1 (1,-1)): ");
Scanner leerX1 = new Scanner(System.in);
double x1 = Double.parseDouble(leerX1.next());
System.out.println("Introduce Entrada X2 (1,-1): ");
Scanner leerX2 = new Scanner(System.in);
double x2 = Double.parseDouble(leerX2.next());
//Pesos ya calibrados para la resolución de puertas XOR.
double w11 = -1.942779536696304;//Pesos neurona 1
double w12 = -2.4033439922084954;
double θ1 = -2.2690966258542424;
double w21 = 1.476484576128277;//Pesos neurona 2
double w22 = 1.5285706752204653;
double θ2 = -1.2654579142409594;
double w31 = -2.7857541174718032;//Pesos neurona 3
double w32 = -2.81730152144229;
double θ3 = -2.52832962325685;
//Calculo de las salidas de las neuronas
double y1 = Math.tanh((x1 * w11) + (x2 * w12) + (1 * θ1));
double y2 = Math.tanh((x1 * w21) + (x2 * w22) + (1 * θ2));
double y3 = Math.tanh((y1 * w31) + (y2 * w32) + (1 * θ3));
y3 = (y3 >= 0) ? 1 : -1;
//Mostrar resultado
System.out.println("Salida (y3) = " + (int) y3);
}
}
Resultado:
run:
Introduce Entrada X1 (1,-1)):
-1
Introduce Entrada X2 (1,-1):
1
Salida (y3) = 1
BUILD SUCCESSFUL (total time: 4 seconds)
Codigo:
package vectorpormatriz;
public class VectorPorMatriz {
public static void main(String[] args) {
int[] x = new int[3];
int[][] w = new int[3][4];
int[] h = new int[w[0].length];
String aux = "";
//LLenar con valores aleatorios w, h, x.
for (int i = 0; i < w.length; i++) {
x[i] = (int) Math.floor(Math.random() * 89) + 10;
for (int j = 0; j < w[0].length; j++) {
w[i][j] = (int) Math.floor(Math.random() * 89) + 10;
}
}
//Multiplica x por w
for (int i = 0; i < w[0].length; i++) {
int sum = 0;
for (int j = 0; j < x.length; j++) {
sum += x[j] * w[j][i];
}
h[i] = sum;
}
//Mostrar vector
System.out.println("* Vector:");
for (int i = 0; i < x.length; i++) {
aux += " " + x[i];
}
System.out.println(aux);
//Mostrar matriz
System.out.println("\n* Matriz:");
for (int[] m1 : w) {
aux = "";
for (int j = 0; j < w[0].length; j++) {
aux += " " + m1[j];
}
System.out.println(aux);
}
//Mostrar resultado
aux = "";
System.out.println("\n* Vector x Matriz:");
for (int i = 0; i < h.length; i++) {
aux += " " + h[i];
}
System.out.println(aux);
}
}
Resultado:
run:
* Vector:
70 62 39
* Matriz:
34 66 31 59
84 75 27 34
25 54 57 35
* Vector x Matriz:
8563 11376 6067 7603
BUILD SUCCESSFUL (total time: 0 seconds)
Codigo:
//Sumatorio
package sumatorio;
import java.util.Scanner;
public class Sumatorio {
public static void main(String[] args) {
//Inicializar variables
int[] x = new int[5];
for (int i = 1; i < x.length; i++) {
System.out.println("Introduce valor X" + i + ":");
Scanner leer = new Scanner(System.in);
x[i] = Integer.parseInt(leer.next());
}
int n = x.length;
int m = 1;
int sumatorio = 0;
String formula = "";
//Sumatorio
for (int i = m; i < n; i++) {
sumatorio += x[i];
formula += " + " + x[i];
}
System.out.println("\n∑ =" + formula.substring(2) + " = " + sumatorio);
}
}
Resultado:
run:
Introduce valor X1:
23
Introduce valor X2:
61
Introduce valor X3:
7
Introduce valor X4:
99
∑ = 23 + 61 + 7 + 99 = 190
BUILD SUCCESSFUL (total time: 11 seconds)
A diferencia del Perceptrón Simple, el Perceptrón Multicapa esta formada por múltiples capas de neuronas. Eliminando la principal limitación del Perceptrón Simple de que no puede resolver problemas que no son linealmente separables como por ejemplo las puertas lógicas XOR.
Codigo:
//Perceptron multicapa
package perceptronMultiCapa;
import java.util.Random;
import java.util.Scanner;
public class PerceptronMultiCapa {
public static void main(String[] args) {
//Introduccion manual de las entradas x1, x2.
System.out.println("Introduce Entrada 1 (X1): ");
Scanner leerX1 = new Scanner(System.in);
double x1 = Double.parseDouble(leerX1.next());
System.out.println("Introduce Entrada 2 (X2): ");
Scanner leerX2 = new Scanner(System.in);
double x2 = Double.parseDouble(leerX2.next());
//Inicializar pesos con valores aleatorios.
double w1 = new Random().nextDouble();
double w2 = new Random().nextDouble();
double w3 = new Random().nextDouble();
double w4 = new Random().nextDouble();
double w5 = new Random().nextDouble();
double w6 = new Random().nextDouble();
//Pesos de la constante θ (ayuda en la precisión).
double θ1 = new Random().nextDouble();
double θ2 = new Random().nextDouble();
double θ3 = new Random().nextDouble();
//Salidas primera capa y ultima (y3)
double y1 = Math.tanh((x1 * w1) + (x2 * w3) - θ1);
double y2 = Math.tanh((x1 * w2) + (x2 * w4) - θ2);
double y3 = Math.tanh((y1 * w5) + (y2 * w6) - θ3);
//Mostrar resultados
System.out.println("Salida (y3) = " + y3);
}
}
Resultado:
run:
Introduce Entrada 1 (X1):
-2.3
Introduce Entrada 2 (X2):
1.9
Salida (y3) = -0.5309976823624457
BUILD SUCCESSFUL (total time: 20 seconds)
Esta vez y siguiendo el ejemplo anterior, lo mismo pero con puerta lógica AND. Solo hace falta substituir los valores de la tabla de verdad del anterior ejemplo por las de la siguiente tabla:
Codigo:
//Aprendizaje puerta logica AND
package neurona4;
import java.util.Random;
import java.util.Scanner;
public class Neurona4 {
public static void main(String[] args) {
//Tabla de la verdad puerta AND (X1,X2,Y1)
int[][] tv = {{1, 1, 1}, {1, -1, -1}, {-1, 1, -1}, {-1, -1, -1}};
double w1 = new Random().nextDouble();
double w2 = new Random().nextDouble();
double θ = -0.4;
double y = 0;
final double E = 0.6;//Factor de aprendizaje
System.out.println("Iniciando fase de aprendizaje puerta logica AND...");
int i = 0;
int cont = 1;
while (i < tv.length && cont < 10000) {
y = Math.tanh((tv[i][0] * w1) + (tv[i][1] * w2) + (-1 * θ));
y = (y >= θ) ? 1 : -1;
if (y == tv[i][2]) {
i++;
} else {
//Ajuste de pesos
w1 = w1 + 2 * E * tv[i][2] * tv[i][0];
w2 = w2 + 2 * E * tv[i][2] * tv[i][1];
θ = θ + 2 * E * tv[i][2] * (-1);
cont++;
i = 0;
}
}
if (cont <= 9999) {
System.out.println("Fase de aprendizaje terminado con exito ");
System.out.println("\nIntroduce Entrada 1 (X1): ");
Scanner leerX1 = new Scanner(System.in);
double x1 = Double.parseDouble(leerX1.next());
System.out.println("Introduce Entrada 2 (X2): ");
Scanner leerX2 = new Scanner(System.in);
double x2 = Double.parseDouble(leerX2.next());
y = Math.tanh((x1 * w1) + (x2 * w2) + (-1 * θ));
y = (y >= θ) ? 1 : -1;
System.out.println("\nSalida: " + y);
} else {
System.out.println("\nFase de aprendizaje ha fallado\n");
}
}
}
Resultado:
run:
Iniciando fase de aprendizaje puerta logica AND...
Fase de aprendizaje terminado con exito
Introduce Entrada 1 (X1):
-1
Introduce Entrada 2 (X2):
1
Salida: -1.0
BUILD SUCCESSFUL (total time: 2 seconds)
Voy a crear un algoritmo de aprendizaje (en este caso una puerta logica OR). Para ello voy a utilizar un tipo de neurona artificial llamada perceptrón con 2 entradas.
Hay que tener encuenta que en este ejemplo, la salida (Y1) solo admite los valores 1 y -1, siguiendo la siguiente regla:
1 si f(wx) >= θ
-1 si f(wx) < θ
Para el aprendizaje de la puerta logica OR nos hará falta crear una "tabla de la verdad" del mismo:
En este nuevo ejemplo de neurona aparecen 2 nuevos valores a tener encuenta:
E = Factor de aprendizaje
θ = Umbral
Y una nueva formula que servirá para ajuste de pesos:
W = W + 2E * T * X
Codigo:
//Aprendizaje puerta logica OR. (Muestra datos paso a paso)
package neuronaOR;
import java.util.Random;
import java.util.Scanner;
public class NeuronaOR {
public static void main(String[] args) {
//Tabla de la verdad (X1,X2,Y1)
int[][] tv = {{1, 1, 1}, {1, -1, 1}, {-1, 1, 1}, {-1, -1, -1}};
System.out.println("\nInicializar pesos:\n");
double w1 = new Random().nextDouble() / 2.5;//valores proximos a 0
double w2 = new Random().nextDouble() / 2.5;
double θ = -0.4;
double y = 0;
final double E = 0.6;//Factor de aprendizaje
System.out.println("w1: " + w1);
System.out.println("w2: " + w2);
System.out.println("θ: " + θ);
System.out.println("\nIniciando fase de aprendizaje puerta logica OR...\n");
int i = 0;
int cont = 1;
while (i < tv.length && cont < 100) {
y = Math.tanh((tv[i][0] * w1) + (tv[i][1] * w2) + (-1 * θ));
y = (y >= θ) ? 1 : -1;
System.out.println("Entrada[" + tv[i][0] + "," + tv[i][1]
+ "]) Valor esperado[" + tv[i][2]
+ "] Salida[" + (int) y + "]");
if (y == tv[i][2]) {
i++;
} else {
System.out.println("Valor esperado difiere de la salida. Hay que reajustar pesos...");
//Ajuste de pesos
w1 = w1 + 2 * E * tv[i][2] * tv[i][0];
w2 = w2 + 2 * E * tv[i][2] * tv[i][1];
θ = θ + 2 * E * tv[i][2] * (-1);
System.out.println("\nAjuste de pesos (" + cont + "):");
System.out.println("w1: " + w1);
System.out.println("w2: " + w2);
System.out.println("θ: " + θ + "\n");
cont++;
i = 0;
}
}
if (cont <= 9999) {
System.out.println("\nFase de aprendizaje terminado con exito ");
System.out.println("\nResultados:");
System.out.println("w1: " + w1);
System.out.println("w2: " + w2);
System.out.println("θ: " + θ);
System.out.println("\nIniciando fase de testeo...");
System.out.println("Introduce Entrada 1 (X1): ");
Scanner leerX1 = new Scanner(System.in);
double x1 = Double.parseDouble(leerX1.next());
System.out.println("Introduce Entrada 2 (X2): ");
Scanner leerX2 = new Scanner(System.in);
double x2 = Double.parseDouble(leerX2.next());
y = Math.tanh((x1 * w1) + (x2 * w2) + (-1 * θ));
y = (y >= θ) ? 1 : -1;
System.out.println("\nSalida: " + (int)y);
} else {
System.out.println("\nFase de aprendizaje ha fallado\n");
}
}
}
Resultado:
run:
Inicializar pesos:
w1: 0.3223614553902566
w2: 0.11581465997718018
θ: -0.4
Iniciando fase de aprendizaje puerta logica OR...
Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[1]
Entrada[-1,1]) Valor esperado[1] Salida[1]
Entrada[-1,-1]) Valor esperado[-1] Salida[1]
Valor esperado difiere de la salida. Hay que reajustar pesos...
Ajuste de pesos (1):
w1: 1.5223614553902567
w2: 1.31581465997718
θ: 0.7999999999999999
Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[-1]
Valor esperado difiere de la salida. Hay que reajustar pesos...
Ajuste de pesos (2):
w1: 2.7223614553902564
w2: 0.1158146599771801
θ: -0.4
Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[1]
Entrada[-1,1]) Valor esperado[1] Salida[-1]
Valor esperado difiere de la salida. Hay que reajustar pesos...
Ajuste de pesos (3):
w1: 1.5223614553902565
w2: 1.31581465997718
θ: -1.6
Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[1]
Entrada[-1,1]) Valor esperado[1] Salida[1]
Entrada[-1,-1]) Valor esperado[-1] Salida[1]
Valor esperado difiere de la salida. Hay que reajustar pesos...
Ajuste de pesos (4):
w1: 2.7223614553902564
w2: 2.5158146599771802
θ: -0.40000000000000013
Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[1]
Entrada[-1,1]) Valor esperado[1] Salida[1]
Entrada[-1,-1]) Valor esperado[-1] Salida[-1]
Fase de aprendizaje terminado con exito
Resultados:
w1: 2.7223614553902564
w2: 2.5158146599771802
θ: -0.40000000000000013
Iniciando fase de testeo...
Introduce Entrada 1 (X1):
1
Introduce Entrada 2 (X2):
-1
Salida: 1
BUILD SUCCESSFUL (total time: 3 minutes 25 seconds)
En este apartado voy a crear una neurona artificial muy básica. Más adelante iré añadiendo nuevas caracteristicas hasta llegar a crear una red neuronal artificial funcional que sea capaz de aprender y resolver problemas complejos.
El funcionamiento de una "neurona" artificial se puede deducir observando el siguiente esquema:
Codigo1 (Perceptron.java):
package neurona2;
import java.util.Random;
public class Perceptron {
public static void main(String[] args) {
//Valores Entradas
double x1 = 1.4;
double x2 = -0.33;
//Valores Pesos (aleatorios)
double w1 = new Random().nextDouble();
double w2 = new Random().nextDouble();
Neurona n = new Neurona(x1, x2, w1, w2);
System.out.println("Entrada 1 (x1): " + x1);
System.out.println("Entrada 2 (x2): " + x2);
System.out.println("Salida 1 (y1) = " + n.getY1());
}
}
Codigo 2 (Neurona.java):
package neurona2;
public class Neurona {
final double x1, x2, w1, w2;
Neurona(double x1, double x2, double w1, double w2) {
this.x1 = x1;
this.x2 = x2;
this.w1 = w1;
this.w2 = w2;
}
public double getY1() {
double wx, y1;
wx = (x1 * w1) + (x2 * w2); //Función propagación
y1 = Math.tanh(wx); //Salida
return y1;
}
}
Resultado:
run:
Entrada 1 (x1): 1.4
Entrada 2 (x2): -0.33
Salida 1 (y1) = -0.2846455790167466
BUILD SUCCESSFUL (total time: 0 seconds)
Usando Netbeans 7.4 creamos un nuevo proyecto con un JFrame Form.
En modo de diseño le agregamos el componente "Progress Bar" y un "Button".
Deberia quedar algo asi:
Codigo Principal:
package barraprogreso1;
public class BarraProgreso1 extends javax.swing.JFrame {
public BarraProgreso1() {
initComponents();
jProgressBar1.setMaximum(100);
}
@SuppressWarnings("unchecked")
private void initComponents() { ... }
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt){
Worker worker = new Worker (jProgressBar1);
worker.execute();
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new BarraProgreso1().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JProgressBar jProgressBar1;
// End of variables declaration
}
Codigo Clase Worker:
package barraprogreso1;
import java.util.List;
import javax.swing.JProgressBar;
import javax.swing.SwingWorker;
public class Worker extends SwingWorker {
private final JProgressBar progreso;
Worker(JProgressBar barra) {
progreso = barra;
}
@Override
public Double doInBackground() throws Exception {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
publish(i + 1);
}
return 100.00;
}
@Override
protected void done() {
System.out.println("Proceso a acabado");
}
@Override
protected void process(List chunks) {
//Actualizando la barra de progreso. Datos del publish.
progreso.setValue(chunks.get(0));
}
}
Resultado:
Las aplicaciones que se utilizaban en los móviles estaban diseñadas en Java (J2ME). Pero con la llegada de los Smartphones con su sistema Android nuestras aplicaciones Java han dejado de funcionar. Hace falta un emulador de Java para sistema Android.
Para ello vamos a tener que instalar el único emulador de Java para Android disponible por el momento (JBED).
Instalación del emulador JBED:
* Requisitos:
1-Tener un smartphone con el sistema Android.
2-Tener instalada en nuestro Smartphone el gestor de archivos "Root Explorer". (se puede descargar desde PlayStore).
3-Descargar el paquete "Jbed.zip", comprobando que Jbed corresponda a la version de tu Android.
* Pasos a seguir:
1- Copiamos "Jbed.zip" dentro nuestro Smartphone Android.
2- Si aún no hemos instalado la aplicación "Root Explorer", procederemos a descargarlo e instalar-lo.
3- Abrimos "Root Explorer" y desde allí descomprimimos el paquete "Jbed.zip". Observamos que se nos ha creado un arbol de carpetas con dos archivos:
/sdcard/extracted/jbed/system/app/Jbed.apk
/sdcard/extracted/jbed/system/app/libjbedvm.so
4- Sin salir del "Root Explorer", movemos los archivos "Jbed.apk" y "libjbedvm.so" y los ponemos en las siguientes rutas respectivamente:
/system/app/Jbed.apk
/system/lib/libjbedvm.so
5- Por último comprobar que esos archivos tengan permisos de lectura y escritura. Si no los tiene se les pueden aplicar desde el mismo Root Explorer.
Nota: En cuanto tenga conocimiento pondré en vuestra disposición los archivos del emulador de java Jbed para Android 4.1.
Para crear un objeto 3D es necesario tener instalada la API Java3D.
Como instalar la API Java3D y agregarla a la IDE de Netbeans pinchar aquí
Codigo:
package esfera3d;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.Sphere;
import com.sun.j3d.utils.universe.SimpleUniverse;
import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.GraphicsConfiguration;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.DirectionalLight;
import javax.media.j3d.Node;
import javax.vecmath.Color3f;
import javax.vecmath.Point3d;
import javax.vecmath.Vector3f;
public final class Esfera3D extends Applet {
public Esfera3D() {
setLayout(new BorderLayout());
GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();
Canvas3D canvas3D = new Canvas3D(config);
add("Center", canvas3D);
BranchGroup escena = crearEscenaGrafico();
SimpleUniverse simpleU = new SimpleUniverse(canvas3D);
simpleU.getViewingPlatform().setNominalViewingTransform();
simpleU.addBranchGraph(escena);
}
public BranchGroup crearEscenaGrafico() {
BranchGroup objPrincipal = new BranchGroup();
objPrincipal.addChild(CrearEsfera());
objPrincipal.addChild(CrearIluminacion());
return objPrincipal;
}
private Node CrearEsfera() {
Sphere esfera = new Sphere(0.3f); //Tamaño esfera (0.3)
return esfera;
}
private Node CrearIluminacion() {
Color3f colorLuz = new Color3f(1.0f, 0.5f, 6.1f);
BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 20.0), 100.0);
Vector3f direccionLuz = new Vector3f(4.0f, -7.0f, -12.0f);
DirectionalLight luz1 = new DirectionalLight(colorLuz, direccionLuz);
luz1.setInfluencingBounds(bounds);
return luz1;
}
public static void main(String[] args) {
Frame frame = new MainFrame(new Esfera3D(), 256, 256); //Tamaño ventana de 256x256 pixeles.
}
}
Resultado:
Nos dirigimos a descargar el paquete Java3D en la pagina oficial de oracle.
API Java 3D
Descargamos la correspondiente "Java 3D 1.5.1" (act. oct-2013).
Instalamos dejando todas las opciones que nos viene por defecto.
Si fuera el caso en que NetbeansIDE no detectara la nueva API de Java3D, habria que agregarla manualmente de la siguiente forma:
Abrimos NetBeans y nos dirigimos a "Tools -> Ant Library -> [New Library...]"
Library Name: Java3D (cambiamos "MyLibrary" por "Java3D")
Library Type: Class Libraries (lo dejamos por defecto)
[Ok]
Nos dirigimos a la libreria que acabamos de crear "Java3D" y le damos al botón [Add JAR/Folder...]
Y agregamos todos los archivos ".JAR" ubicados en la siguiente ruta:
"C:\Program Files\Java\Java3D\1.5.1\lib\ext".
Y le damos al [Ok].
Nos dirigimos al menú Projects, carpeta Libraries -> Add Library...
Elegimos "Java3D" y pulsamos botón [Add Library].
Listo.
Código
package triangulopascal;
public class TrianguloPascal {
public static void main(String[] args) {
int nfilas = 10;
int[] a = new int[1];
for (int i = 1; i <= nfilas; i++) {
int[] x = new int[i];
for (int j = 0; j < i; j++) {
if (j == 0 || j == (i - 1)) {
x[j] = 1;
} else {
x[j] = a[j] + a[j - 1];
}
System.out.print(x[j] + " ");
}
a = x;
System.out.println();
}
}
}
Resultado:
run:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
BUILD SUCCESSFUL (total time: 0 seconds)
En el siguiente ejemplo tenemos una baraja que consta de 10 cartas que vamos a mezclar aleatoriamente para luego mostrarlo en pantalla.
Codigo:
//Números aleatorios sin repetición
package aleatorisinrepeticion;
import java.util.Stack;
public class AleatoriSinRepeticion {
public static void main(String[] args) {
int pos;
int nCartas = 10;
Stack < Integer > pCartas = new Stack < Integer > ();
for (int i = 0; i < nCartas ; i++) {
pos = (int) Math.floor(Math.random() * nCartas );
while (pCartas.contains(pos)) {
pos = (int) Math.floor(Math.random() * nCartas );
}
pCartas.push(pos);
}
System.out.println("Núm. aleatorios sin repetición:");
System.out.println(pCartas.toString());
}
}
Resultado:
run:
Núm. aleatorios sin repetición:
[2, 8, 5, 7, 6, 3, 0, 9, 4, 1]
BUILD SUCCESSFUL (total time: 0 seconds)
Codigo:
package vectortaula;
public class VectorTaula {
public static void main(String[] args) {
int vDist[] = {774, 647, 192, 754, 515, 578, 861, 947, 253};
int n= (int)Math.sqrt(vDist.length);
int taula[][] = new int[n][n];
int cont = 0;
for (int x = 0; x < n; x++) {
for (int y = 0; y < n; y++) {
taula[y][x] = vDist[cont];
cont++;
}
}
MostrarTaula(taula, n);
}
private static void MostrarTaula(int[][] taula, int n) {
System.out.println("Matriz:");
String str = "";
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
str += taula[j][i] + "\t";
}
System.out.println(str);
str = "";
}
}
}
Resultado:
run:
Matriz:
774 647 192
754 515 578
861 947 253
BUILD SUCCESSFUL (total time: 0 seconds)
Se puede utilizar para tablas de distancias entre nodos, donde la distancia entre el nodo A y el B y viceversa son equivalentes.
Codigo:
package taulatriangular1;
public class TaulaTriangular1 {
public static void main(String[] args) {
int nNodes = 5;
int vDist[] = {774, 647, 192, 754, 515, 578, 861, 947, 253, 496};
int taula[][] = new int[nNodes][nNodes];
int cont = 0;
for (int i = 0; i < nNodes; i++) {
for (int j = 0; j < nNodes; j++) {
if (j == i) {
taula[i][j] = 0;
}
if (j > i) {
taula[i][j] = vDist[cont];
taula[j][i] = taula[i][j];
cont++;
}
}
}
mostrarTaula(taula, nNodes);
}
private static void mostrarTaula(int[][] taula, int nNodes) {
String str = "";
for (int i = 0; i < nNodes; i++) {
for (int j = 0; j < nNodes; j++) {
str += taula[i][j] + "\t";
}
System.out.println(str);
str = "";
}
}
}
Resultado:
run:
0 774 647 192 754
774 0 515 578 861
647 515 0 947 253
192 578 947 0 496
754 861 253 496 0
BUILD SUCCESSFUL (total time: 0 seconds)
