Desde Netbeans en modo diseño se añaden los componentes siguiendo esta estructura:
-----------------------------------------------------------------
. JFrame (title: "Graficando perceptrón")
. jPanel1 (aqui se graficará la red neuronal)
. jToolBar1 (barra de opciones)
. jLabel1 (texto: "Estructura")
. jTextField1 (texto: "2,4,4,1")
. jButton1 (texto: "Graficar")
. jButton2 (texto: "Limpiar")
-----------------------------------------------------------------
Código 1 (Muro.java):
package centrar;
public class Muro extends javax.swing.JFrame {
public Muro() {
initComponents();
this.setLocationRelativeTo(null);
}
private void initComponents() { ... } // <- código generado automáticament por Netbeans
private void jButtonGraficarActionPerformed(java.awt.event.ActionEvent evt) {
Dibujar t = new Dibujar(jPanel1.getGraphics(), jPanel1.getWidth(), jPanel1.getHeight(), jTextField1.getText());
}
private void jButtonLimpiarActionPerformed(java.awt.event.ActionEvent evt) {
this.jPanel1.repaint();
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Muro().setVisible(true);
}
});
}
private javax.swing.JButton jButtonGraficar;
private javax.swing.JButton jButtonLimpiar;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JToolBar.Separator jSeparator1;
private javax.swing.JToolBar.Separator jSeparator2;
private javax.swing.JTextField jTextField1;
private javax.swing.JToolBar jToolBar1;
}
Código 2 (Dibujar.java):
package centrar;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Stroke;
import java.util.ArrayList;
import java.util.List;
public class Dibujar {
Graphics g;
Graphics2D g2;
public Dibujar(Graphics g, int width, int height, String estruct) {
g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setColor(Color.BLACK);
// tipos grosores pinceles
Stroke stroke02 = new BasicStroke(0.2f);
Stroke stroke04 = new BasicStroke(0.4f);
g2.setStroke(stroke02);
// añadir datos estructura perceptrón
List<Integer> estructura = new ArrayList<>();
for (String aux1 : estruct.split(",")) {
estructura.add(Integer.parseInt(aux1));
}
int maxX = estructura.size();
int maxY = maximo(estructura);
int nParticionesX = maxX + 2; // se suma 2 para margen superior e inferior
int nParticionesY = maxY + 2; // se suma 2 para margen superior e inferior
int uX = width / nParticionesX;
int uY = height / nParticionesY;
float uSeparadorX = (nParticionesX - estructura.size()) / 2f;
float uSeparadorY;
int posIniX = (int) Math.round(uX * uSeparadorX);
int posIniY;
int[][][] recopilador = new int[maxX][maxY][2]; // k, x, y
// capa 0: pre-logical posiciones
for (int x = 0; x < estructura.size(); x++) {
for (int y = 0; y < estructura.get(x); y++) {
uSeparadorY = (nParticionesY - estructura.get(x)) / 2f;
posIniY = (int) Math.round(uY * uSeparadorY);
recopilador[x][y][0] = (posIniX + (int) uX * x) + (int) (uX / 2);
recopilador[x][y][1] = (posIniY + (int) uY * y) + (int) (uY / 2);
}
}
// capa 1: graficar neuronas
int radio = (int) Math.round(uY / 2f);
for (int x = 0; x < estructura.size(); x++) {
for (int y = 0; y < estructura.get(x); y++) {
centrarCirculo(g2, recopilador[x][y][0], recopilador[x][y][1], radio);
}
}
// capa 2: graficar enlaces
int x1, y1, x2, y2;
g2.setColor(Color.DARK_GRAY);
g2.setStroke(stroke04);
for (int x = 0; x < estructura.size() - 1; x++) {
for (int y = 0; y < estructura.get(x); y++) {
for (int k = 0; k < estructura.get(x + 1); k++) {
x1 = recopilador[x][y][0];
y1 = recopilador[x][y][1];
x2 = recopilador[x + 1][k][0];
y2 = recopilador[x + 1][k][1];
g2.drawLine(x1, y1, x2, y2);
}
}
}
}
private void centrarCirculo(Graphics g2, int x, int y, int r) {
x = x - (r / 2);
y = y - (r / 2);
g2.fillOval(x, y, r, r);
}
/* Busca número mayor del listado de la estructura
* Utilizado para acomodar la gráfica al tamaño de la ventana
*/
private int maximo(List<Integer> estructura) {
int max = 0;
for (int i = 0; i < estructura.size(); i++) {
if (estructura.get(i) >= max) {
max = estructura.get(i);
}
}
return max;
}
}
Resultado:
