GRAFOS EN JAVA

Estructura de Datos: Grafos

Un Grafo no es mas que un conjunto de nodos o vrtices que se encuentran
relacionados con unas aristas. Ademas los vrtices tienen un valor y
en ocasiones las aristas tambin y se le conoce como el costo.
Representacin Grfica de un Grafo

Como se puede ver los puntos son los nodos o vrtices, y las lineas son las aristas, en el caso
de la imagen es la representacin grfica de un grafo dirigido ya que las aristas tienen
un nico sentido, ya que de A a D se puede ir pero de D a A no. Si el grafo fuera no dirigido
se podra ya que las aristas no tienen direccin.

Aplicacin
La teora de Grafos se aplica hoy en da en muchos campos, tales como en Internet, ya que
cada computador es un vrtice y la conexin entre ellos son las aristas, ademas se usa para
hallar la ruta mas corta en empresas de transporte, y en muchas otras reas.

Imgenes
Cdigo
Clase Principal
package Clases;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;

import javax.swing.*;

public class Principal extends JApplet{

PanelDibujo pd;
int max=0;
JTextField valor;

public void init(){

pd=new PanelDibujo();
add(pd);

JPanel pdatos=new JPanel();

 JButton agregar=new JButton("Agregar Nodo");
agregar.addActionListener(new ActionListener(){

@Override
public void actionPerformed(ActionEvent e) {
if(max<10){
try{
Grafo gf=new Grafo(""+Integer.parseInt(valor.getText()));
pd.getVgrafos().add(gf);
pd.repaint();
repaint();
max++;
}catch(NumberFormatException ne){
JOptionPane.showMessageDialog(null, "Digite un numero valido");
}
}
}
});

valor=new JTextField(5);
pdatos.add(new JLabel("Valor Vertice" +
""));
pdatos.add(valor);
pdatos.add(agregar);
add(pdatos,BorderLayout.SOUTH);

Clase PanelDibujo
package Clases;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.Vector;

import javax.swing.*;

public class PanelDibujo extends JPanel {

int x=150;
int y=150;
int ancho=30;
int alto=30;
public Vector<Integer> xvs;
public Vector<Integer> yvs;
public Vector<Grafo> vgrafos;
int indice=0;
public PanelDibujo(){
vgrafos=new Vector();
xvs=new Vector<Integer>();
yvs=new Vector<Integer>();
setDoubleBuffered(true);
}

public void paintComponent(Graphics grafico){

super.paintComponents(grafico);
Graphics2D g=(Graphics2D)grafico;
if(vgrafos.size()!=0){
g.setColor(Color.WHITE);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(Color.BLACK);
int radio = 100;
float angulo = 360/10;
angulo = (float) Math.toRadians(angulo);
for(int i=indice;i<vgrafos.size();i++){
int xv=(int)(x+radio*Math.cos(i * angulo));
int yv=(int) (y- radio * Math.sin(i * angulo));
xvs.add(xv);
yvs.add(yv);
indice++;
}
}
for(int i=0;i<vgrafos.size();i++){
for(int j=0;j<vgrafos.size();j++){
g.setStroke(new BasicStroke(2));
g.setColor(Color.BLACK);
g.drawLine(xvs.get(i)+15,yvs.get(i)+15,xvs.get(j)+15,yvs.get(j)+15);
g.setColor(Color.WHITE);
g.fillOval(xvs.get(i), yvs.get(i), ancho, alto);
g.setColor(Color.BLACK);
g.drawOval(xvs.get(i),yvs.get(i), ancho, alto);
g.drawString(""+vgrafos.get(i).obtenerDato(), xvs.get(i)+((ancho/2)-3),
yvs.get(i)+((alto/2)+3));
g.setColor(Color.WHITE);
g.fillOval(xvs.get(j), yvs.get(j), ancho, alto);
g.setColor(Color.BLACK);
g.drawOval(xvs.get(j),yvs.get(j), ancho, alto);
g.drawString(""+vgrafos.get(j).obtenerDato(), xvs.get(j)+((ancho/2)-3),
yvs.get(j)+((alto/2)+3));
}
}
}
public Vector<Grafo> getVgrafos() {
return vgrafos;
}
public void setVgrafos(Vector<Grafo> vgrafos) {
this.vgrafos = vgrafos;
}
}
Clase Grafo
package Clases;

import java.util.Vector;

public class Grafo {

private String dato;

public Grafo(String s){

dato=s;
}

public String obtenerDato(){

return dato;
}
}

La clase Grafo solo es para almacenar el valor de cada grafo, ademas as es mas orientada a
objetos y facilita la programacin.

La clase PanelDibujo es la que se encargar de dibujar los vrtices o nodos y de pintar las lineas
que vendran a hacer las aristas. Ademas dibuja el valor del vrtice. En esta clase hay una parte
del cdigo que es pura matemtica, esto lo que hace es hacer que el grafo pinte los nodos en
forma circular y as hacer que se vea mas limpia a la vista la grfica.

Lo que hacemos es primero calcular el angulo de separacin entre nodos, por eso 360 lo divido
entre 10, ya que este es el mximo de vrtices a dibujar. Y luego en el para el angulo se va
multiplicando por i, para poder ir movindose y as dibujar correctamente el grafo.

La clase Principal es la encargada de crear el campo de texto para colocar el valor del vrtice a
insertar y de crear el botn que va ir aadiendo vrtices al grafo.

Grafo Dinmico
Ahora veremos como podemos ir construyendo nuestro grafo sencillo paso a paso, podemos ir
colocando nuestros nodos y despues ir asignando las aristas. Este proyecto fue aportado
por Michael Manjarres.

Imgenes
Cdigo

Clase Principal

package Clases;

import javax.swing.JApplet;

public class Principal extends JApplet {

public void init(){

lienzo l=new lienzo(this);
l.setBounds(0, 0, 400, 400);
add(l);
 }
}

Clase lienzo
package Clases;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class lienzo extends JPanel implements MouseListener,MouseMotionListener{

int x=0,y=0;
linea linea;
circulo circulo;
circulo jalada=null;
List<circulo> ListCirculo = new ArrayList<circulo>();
List<linea> ListArista = new ArrayList<linea>();
Principal p;

public lienzo(Principal prin) {

p=prin;
this.addMouseListener(this);
this.addMouseMotionListener(this);
this.setVisible(true);
this.setDoubleBuffered(true);
}

public void anadirCirculo(int x, int y){

circulo = new circulo(ListCirculo.size(),x,y);
ListCirculo.add(circulo);
repaint();
p.repaint();
}

public void anadirLinea( int x, int y){

try{
linea = new linea (ListCirculo.get(x),ListCirculo.get(y));
this.ListArista.add(linea);
repaint();
p.repaint();
}catch(IndexOutOfBoundsException e){
JOptionPane.showMessageDialog(null, "No se encontro circulo");
}
}
 @Override
public void paintComponent(Graphics g){
super.paintComponents(g);
for (linea f:ListArista)
{
f.painter(g);
}

for (circulo f:ListCirculo)

{
f.painter(g,this);
}

public void mouseClicked(MouseEvent e) {

try{
if(e.getButton()==1){
x = e.getX();
y = e.getY();
anadirCirculo(x,y);
}else
{
if(e.getButton()==3)
{
int ini = Integer.parseInt(JOptionPane.showInputDialog("Numero de circulo
inicual"));
int fin = Integer.parseInt(JOptionPane.showInputDialog("Numero de circulo
final"));
anadirLinea(ini, fin);
}
}
}catch(Exception ex){

}
}

public void mousePressed(MouseEvent e) {}

public void mouseReleased(MouseEvent e) {}

public void mouseEntered(MouseEvent e) {}

public void mouseExited(MouseEvent e) {}

public void mouseDragged(MouseEvent e) {

if(jalada==null)
{
for (circulo f:ListCirculo)
{
if(f.jaladopor(e.getPoint()))
{
jalada=f;
 }
x=e.getPoint().x;
y=e.getPoint().y;
repaint();
p.repaint();
}
}
else{
jalada.transladar(e.getPoint().x-x,e.getPoint().y-y);
x=e.getPoint().x;
y=e.getPoint().y;
repaint();
p.repaint();
}
}

public void mouseMoved(MouseEvent e){

jalada=null;
}

Clase circulo
package Clases;

import java.awt.*;
import javax.swing.ImageIcon;

public class circulo{

int x,y,n;
Image image;

public circulo(int n, int x, int y) {

this.n=n;
this.x=x;
this.y=y;
image = new
ImageIcon(getClass().getResource("../Imagenes/esfera.png")).getImage();
}

public void painter(Graphics g,lienzo l) {

g.drawImage(image, x-15, y-15, l);
g.setColor(Color.RED);
g.drawString(""+n, x-15, y-15);
g.drawString(""+n, x-14, y-14);
}

public int getX() {

return x;
}
 public int getY() {
return y;
}

public int getN() {

return n;
}

public void transladar(int dx,int dy) {

this.x+=dx; this.y+=dy;
}

public void setImage(Image image) {

this.image = image;
}

public boolean jaladopor(Point d) {

if(d.distance(x, y)<=15) {
return true;
}
else {
return false;
}
}
}

Clase linea
package Clases;

import java.awt.Color;
import java.awt.Graphics;

public class linea{

circulo inicial;
circulo ffinal;
Color color= Color.BLACK;

public linea(circulo inicial, circulo ffinal) {

this.inicial=inicial;
this.ffinal=ffinal;
}

public void painter(Graphics g) {

g.setColor(Color.BLUE);
g.setColor(color);
g.drawLine(inicial.getX(), inicial.getY(), ffinal.getX(), ffinal.getY());
}

public void setColor(Color color) {

this.color = color;
}
 public circulo getFfinal() {
return ffinal;
}

public circulo getInicial() {

return inicial;
}

La clase Principal solo crea un objeto lienzo y lo adiciona para ser mostrado. La clase lienzo es
la encargada de mostrar el grafo, en ella se encuentran dos listas las cuales guardan los nodos
y las lineas que se han creado, para luego ser dibujados en el metodo paintComponent.

La clase circulo tiene la imagen que representa un nodo, ademas muestra el indice del nodo.
La clase linea posee dos nodos el inicial y el final, para poder dibujar la linea entre dichos nodos.