Graficando red neuronal (perceptrón).

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: