package objetos;

public class Arista{

private int idArista;
private String nombreArista;
private int distancia;//Distancia entre dos puntos
private LineaQuebrada lineaQuebrada;//�sta es la via representada graficamente

private boolean habilitado;

public Arista(){
// Inicializando variables de instancia
this(-1,"");
}
public Arista(int idArista){
// Inicializando variables de instancia
this(-1,"");
}
public Arista(int idArista,String nombreArista){
// Inicializando variables de instancia
this(-1,"",1);
}
public Arista(int idArista,String nombreArista,int peso){
// Inicializando variables de instancia
this.idArista = idArista;
this.nombreArista = nombreArista;
this.distancia = peso;
lineaQuebrada = null;
habilitado = true;
}
public void setIdArista(int idArista){
this.idArista = idArista;
}
public int getIdArista(){
return idArista;
}
public void setNombreArista(String nombreVia){
this.nombreArista = nombreVia;
}
public String getNombreArista(){
return nombreArista;
}
public void setPeso(int peso){
this.distancia = peso;
}
public int getPeso(){
return distancia;
}
public void setLineaQuebrada(LineaQuebrada lineaQuebrada){
this.lineaQuebrada = lineaQuebrada;
if(lineaQuebrada != null){
this.lineaQuebrada.setLongitud(distancia);
}
}
public LineaQuebrada getLineaQuebrada(){
return lineaQuebrada;
}

public boolean isHabilitado() {

 return habilitado;
}

public void setHabilitado(boolean habilitado) {

this.habilitado = habilitado;
}
}
___________________________________________________________________________________
__________________________________
package objetos;
import java.awt.*;

public class Circulo

{
// Instanciando Variables
private Coordenadas coordenadas;
private Color color;
private int diametro;
private String etiqueta;
private Font fuente;
private int izquierda;
private int grosorBorde;
/**
* Constructor para objetos de la clase circulo
*/
public Circulo(Coordenadas coordenadas){
// inicializando variables de instancia
this.coordenadas = coordenadas;
color = Color.yellow;
diametro = 10;
etiqueta = "";
fuente = null;
izquierda = 0;
grosorBorde = 2;
}
public void dibujarCirculo(Graphics g){
if(coordenadas.size() > 0){
((Graphics2D)g).setColor(color);

((Graphics2D)g).setStroke(new BasicStroke(getGrosorBorde()));

((Graphics2D)g).fillOval(coordenadas.get(0)[0],coordenadas.get(0)
[1],diametro,diametro);
((Graphics2D)g).setColor(Color.black);
((Graphics2D)g).drawOval(coordenadas.get(0)[0],coordenadas.get(0)
[1],diametro,diametro);
if(!"".equals(etiqueta)){
if(fuente != null){
g.setFont(fuente);
}

((Graphics2D)g).drawString(etiqueta,coordenadas.get(0)[0] -
(izquierda),coordenadas.get(0)[1]);

((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
}
}else{
 System.out.println("No hay coordenadas para el circulo");
}
}
public void setColor(Color color){
this.color = color;
}
public Color getColor(){
return color;
}
public void setDiametro(int diametro){
this.diametro = diametro;
}
public int getDiametro(){
return diametro;
}
public void setEtiqueta(String etiqueta){
this.etiqueta= etiqueta;
}
public void setEtiqueta(String etiqueta,boolean izquierda){
this.etiqueta= etiqueta;
}
public String getEtiqueta(){
return etiqueta;
}
public int getX(){
if(coordenadas.size() > 0){
return coordenadas.get(0)[0];
}else{
return -1;
}
}
public int getY(){
if(coordenadas.size() > 0){
return coordenadas.get(0)[1];
}else{
return -1;
}
}

public Font getFuente() {

return fuente;
}

public void setFuente(Font fuente) {

this.fuente = fuente;
}

public int isIzquierda() {

return izquierda;
}

public void setIzquierda(int izquierda) {

this.izquierda = izquierda;
}

public int getGrosorBorde() {

return grosorBorde;
}
 public void setGrosorBorde(int grosorBorde) {
this.grosorBorde = grosorBorde;
}

}
___________________________________________________________________________________
_____________________________
package objetos;
import java.util.ArrayList;

public class Coordenadas extends ArrayList < int[] >

{
private int xMaxima;
private int yMaxima;
public Coordenadas(){
// inicializando variables de instancia
this(0, 0);
}
public Coordenadas(int xMaxima, int yMaxima){
// inicializando variables de instancia
super();
this.xMaxima = xMaxima;
this.yMaxima = yMaxima;
}
public Coordenadas(int xMaxima, int yMaxima,int x, int y){
// inicializando variables de instancia
super();
this.xMaxima = xMaxima;
this.yMaxima = yMaxima;
addCoordenada(x,y);
}
public void setXMaxima(int xMaxima){
this.xMaxima = xMaxima;
}
public void setYMaxima(int yMaxima){
this.yMaxima = yMaxima;
}
public void addCoordenada(int x, int y){
if(x >= 0 && x <= xMaxima && y >= 0 && y <= yMaxima)
{
int[] parXY = {x, y};
add(parXY);
}
}

public int getxMaxima() {

return xMaxima;
}

public int getyMaxima() {

return yMaxima;
}

}
___________________________________________________________________________________
________________
package objetos;

public class Enlace{

 private Arista arista;
private Nodo nodo;

/**
* Constructor para objetos de la clase Arista
*/
public Enlace(){
// inicializando variables de instancia
this(new Arista(),new Nodo());
}
public Enlace(Arista arista,Nodo nodo){
// inicializando variables de instancia
this.arista = arista;
this.nodo = nodo;
}
public void setArista(Arista arista){
this.arista = arista;
}
public Arista getArista(){
return arista;
}
public void setNodo(Nodo nodo){
this.nodo = nodo;
}
public Nodo getNodo(){
return nodo;
}
}

___________________________________________________________________________________
_____________
package objetos;

import java.awt.Color;
import java.util.ArrayList;

public class Grafo{

private ArrayList<Nodo> listaNodo;

public Grafo(){
listaNodo = new ArrayList<Nodo>();
}
public boolean adjuntarNodo(Nodo nodo){
Nodo nodoTemp = buscarNodo(nodo.getDato());
if(nodoTemp == null){
listaNodo.add(nodo);
return true;
}else{
return false;
}
}

public void crearEnlacesDirigido(Nodo padre,Nodo adyacente,Arista arista){

if(padre != null && adyacente != null){
padre.addNodoAdyacente(arista,adyacente);
}
}

public void crearEnlacesNoDirigido(Nodo padre,Nodo adyacente,Arista arista){

 crearEnlacesDirigido(padre, adyacente, arista);
crearEnlacesDirigido(adyacente,padre, arista);
}

public Nodo buscarNodo(Object dato){

Nodo temp = null;
if(dato != null){
for(Nodo nodo:listaNodo){
if(dato.equals(nodo.getDato())){
temp = nodo;
}
}
}
return temp;
}
public Nodo buscarNodo(int x, int y){
Nodo nodoAuxiliar = null;
for(int i = 0; i < listaNodo.size(); i++){
int xNodo = listaNodo.get(i).getCirculo().getX();
int yNodo = listaNodo.get(i).getCirculo().getY();
if(x > xNodo && x < (xNodo +
listaNodo.get(i).getCirculo().getDiametro())){
if(y > yNodo && y < (yNodo +
listaNodo.get(i).getCirculo().getDiametro())){
nodoAuxiliar = listaNodo.get(i);
break;
}
}
}
return nodoAuxiliar;
}

public ArrayList<Nodo> getAdyacentes(Object dato){

ArrayList<Nodo> lista = null;
Nodo principal = buscarNodo(dato);
ArrayList<Enlace> aristas = principal.getListaNodoAdyacente();
if(aristas != null){
for(int i = 0; i < aristas.size();i++){
lista.add(aristas.get(i).getNodo());
}
}
return lista;
}
public ArrayList<Nodo> getListaNodos(){
return listaNodo;
}
public boolean isAdyacente(Nodo n1,Nodo n2){
boolean aux = false;
ArrayList<Enlace> listaAristas = n1.getListaNodoAdyacente();
if(listaAristas != null){
for(int i = 0;i < listaAristas.size();i++){
if(listaAristas.get(i).getNodo() == n2){
aux = true;
}
}
}
return aux;
}
public boolean isAdyacente(Object datoNodoInicio,Object datoNodoDestino){
boolean aux = false;
Nodo n1 = buscarNodo(datoNodoInicio);
Nodo n2 = buscarNodo(datoNodoDestino);
ArrayList<Enlace> listaAristas = n1.getListaNodoAdyacente();
if(listaAristas != null){
for(int i = 0;i < listaAristas.size();i++){
if(listaAristas.get(i).getNodo() == n2){
aux = true;
}
}
}
return aux;
}
public Arista getArista(Object datoNodo1,Object datoNodo2){
return getArista(buscarNodo(datoNodo1),buscarNodo(datoNodo2));
}
public Arista getArista(String nombreVia){
Arista aux = null;
if(nombreVia != null){
ArrayList<Nodo> listaN = listaNodo;
for(Nodo nd:listaN){
ArrayList<Enlace> lA = nd.getListaNodoAdyacente();
for(Enlace enlace:lA){
if(enlace.getArista().getNombreArista().equals(nombreVia)){
aux = enlace.getArista();
}
}
}
}
return aux;
}
public Arista getArista(Nodo n1,Nodo n2){
Arista aux = null;
if(isAdyacente(n1, n2)){
ArrayList<Enlace> listaAristas = n1.getListaNodoAdyacente();
for(int i = 0;i < listaAristas.size();i++){
if(listaAristas.get(i).getNodo() == n2){
aux = listaAristas.get(i).getArista();
}
}
}else if(isAdyacente(n2, n1)){
aux = getArista(n2, n1);
}
return aux;
}
public Enlace getEnlace(Object datoNodo1,Object datoNodo2){
Enlace aux = null;
if(isAdyacente(datoNodo1, datoNodo2)){
Nodo n1 = buscarNodo(datoNodo1);
Nodo n2 = buscarNodo(datoNodo2);
ArrayList<Enlace> listaAristas = n1.getListaNodoAdyacente();
for(int i = 0;i < listaAristas.size();i++){
if(listaAristas.get(i).getNodo() == n2){
aux = listaAristas.get(i);
}
}
}
 else if(isAdyacente(datoNodo2, datoNodo1)){
aux = getEnlace(datoNodo2, datoNodo1);
}
return aux;
}
public void reiniciarGrafoParaDisjktra(){
for(Nodo n:listaNodo){
n.setMarca(false);
n.setNodoAntecesorDisjktra(null);
n.setLongitudCamino(-1);
}
}

public boolean eliminarNodo(Nodo nodo){

boolean retornado = false;
if(nodo !=null){
retornado = listaNodo.remove(nodo);
}
return retornado;
}

public void reiniciarColores() {

if(listaNodo != null){
for(Nodo nodo: listaNodo){
nodo.getCirculo().setColor(Color.yellow);
ArrayList<Enlace> la = nodo.getListaNodoAdyacente();
if(la != null){
for(Enlace enlace:la){
if(enlace.getArista().isHabilitado()){

enlace.getArista().getLineaQuebrada().setColor(Color.black);

enlace.getArista().getLineaQuebrada().setGrosorLinea(1);
}
}
}
}
}
}
public ArrayList<Arista> aristasEntrante(Nodo nodo){
ArrayList<Arista> listaArista = null;
for(Nodo n:listaNodo){
ArrayList<Enlace> enlaces = n.getListaNodoAdyacente();
if(enlaces != null){
listaArista = new ArrayList<Arista>();
for(Enlace e:enlaces){
if(e.getNodo()==nodo){
listaArista.add(e.getArista());
}
}
}
}
return listaArista;
}
public ArrayList<Arista> aristasSaliente(Nodo nodo){
ArrayList<Arista> listaArista = null;
if(nodo != null){
if(listaNodo.contains(nodo)){
ArrayList<Enlace> listaEnlace = nodo.getListaNodoAdyacente();
 if(listaArista != null){
listaArista = new ArrayList<Arista>();
for(Enlace e:listaEnlace){
listaArista.add(e.getArista());
}
}
}
}
return listaArista;
}

private void eliminarAristas(Nodo nodo){

ArrayList<Arista> aristas = aristasSaliente(nodo);
for(Arista a:aristas){
a = null;
}
}
public void eliminarAristasSalientes(Nodo nodo){
ArrayList<Arista> aristas = aristasSaliente(nodo);
eliminarAristas(nodo);
}
public void eliminarAristasEntrante(Nodo nodo){
ArrayList<Arista> aristas = aristasEntrante(nodo) ;
eliminarAristas(nodo);
}
}
___________________________________________________________________________________
_________________
package objetos;
import java.awt.*;

public class LineaQuebrada

{
// Instanciando variables
private Coordenadas coordenadas;
private Color color;
private float grosorLinea;
private String etiqueta;
private int longitud;
private boolean mostrarEtiqueta;
/**
* Constructor para objetos de la clase Lineaquebrada
*/
public LineaQuebrada(Coordenadas coordenadas){
// inicializando variables de instancia
this.coordenadas = coordenadas;
grosorLinea = 1f;
color = Color.black;
mostrarEtiqueta = true;
}
public void dibujarLineaQuebrada(Graphics g){
((Graphics2D)g).setColor(getColor());
((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
BasicStroke stroke = new BasicStroke(grosorLinea);
((Graphics2D)g).setStroke(stroke);
if(coordenadas != null){
int []aux = new int[0];
for(int i = 0; i < coordenadas.size(); i++){
 aux = coordenadas.get(i);
if(i == 0){
((Graphics2D)g).drawLine(aux[0],aux[1],aux[0],aux[1]);
}else{
((Graphics2D)g).drawLine(coordenadas.get(i - 1)
[0],coordenadas.get(i - 1)[1],aux[0],aux[1]);
}
}

if(mostrarEtiqueta){
((Graphics2D)g).setColor(Color.blue);
Font fuente=new Font("Monospaced",Font.BOLD, 12);
g.setFont(fuente);

if(coordenadas.size() == 2){
int xMenor = menor(coordenadas.get(0)[0],coordenadas.get(1)
[0]);
int yMenor = menor(coordenadas.get(0)[1],coordenadas.get(1)
[1]);

int xMayor = mayor(coordenadas.get(0)[0],coordenadas.get(1)

[0]);
int yMayor = mayor(coordenadas.get(0)[1],coordenadas.get(1)
[1]);

int distanciaVertical = yMayor - yMenor;

int distanciaHorizontal = xMayor - xMenor;
((Graphics2D)g).drawString(longitud+"",(distanciaHorizontal/2)
+ xMenor,(distanciaVertical/2) + yMenor);
}else{
int pos = coordenadas.size() / 2;

((Graphics2D)g).drawString(longitud+"",coordenadas.get(pos)
[0]+3,coordenadas.get(pos)[1]-8);

}
}
}

stroke = new BasicStroke(1);

((Graphics2D)g).setStroke(stroke);

}
private int mayor(int n1,int n2){
return (n1 > n2) ? n1 : n2;
}
private int menor(int n1,int n2){
return (n1 < n2) ? n1 : n2;
}
public void setColor(Color color){
this.color = color;
}
public Color getColor(){
return color;
}
public void setGrosorLinea(float grosorLinea){
this.grosorLinea = grosorLinea;
}
 public float getGrosorLinea(){
return grosorLinea;
}
public void setEtiqueta(String etiqueta){
this.etiqueta= etiqueta;
}
public String getEtiqueta(){
return etiqueta;
}

public int getLongitud() {

return longitud;
}

public void setLongitud(int longitud) {

this.longitud = longitud;
}

public Coordenadas getCoordenadas() {

return coordenadas;
}

public void setCoordenadas(Coordenadas coordenadas) {

this.coordenadas = coordenadas;
}

public boolean isMostrarEtiqueta() {

return mostrarEtiqueta;
}

public void setMostrarEtiqueta(boolean mostrarEtiqueta) {

this.mostrarEtiqueta = mostrarEtiqueta;
}

}
___________________________________________________________________________________
______________________
package objetos;
import java.util.ArrayList;

public class Nodo{

private Object dato;
private ArrayList<Enlace> listaNodoAdyacente;
private boolean visitado = false;
private Circulo circulo;
private int izquierda;

private int longitudCamino; //Para uso de la clase Disjktra

private Nodo nodoAntecesorDisjktra; //Para uso de la clase Disjktra
private boolean marca;//Para uso de la clase Disjktra

public Nodo(){
this.dato = new Object();
circulo = null;
izquierda = 0;
inicializarParaDisjktra();
}

private void inicializarParaDisjktra(){

 longitudCamino = -1;
nodoAntecesorDisjktra = null;
marca = false;
}

public Nodo(Object dato,Coordenadas coordenada){

this.dato = dato;
listaNodoAdyacente = new ArrayList<Enlace>();
circulo = new Circulo(coordenada);
circulo.setIzquierda(izquierda);
inicializarParaDisjktra();
}

public void setDato(Object dato){

this.dato = dato;
}
public Object getDato(){
return this.dato;
}
public ArrayList<Enlace> getListaNodoAdyacente(){
ArrayList<Enlace> listAristaAux = null;
if(!listaNodoAdyacente.isEmpty()){
listAristaAux = new ArrayList<Enlace>();
for(Enlace enlace:listaNodoAdyacente){
if(enlace.getArista().isHabilitado()){
listAristaAux.add(enlace);
}
}
}
return listAristaAux;
}

public void addNodoAdyacente(Enlace arista){

listaNodoAdyacente.add(arista);
}
public void addNodoAdyacente(Arista via,Nodo nodo){
this.addNodoAdyacente(new Enlace(via,nodo));
}
public void setVisitado(boolean visitado){
this.visitado = visitado;
}
public boolean isVisitado(){
return visitado;
}

public Circulo getCirculo() {

return circulo;
}

public void setCirculo(Circulo circulo) {

this.circulo = circulo;
}

public int getLongitudCamino() {

return longitudCamino;
}

public void setLongitudCamino(int longitudCamino) {

this.longitudCamino = longitudCamino;
 }

public boolean isMarca() {

return marca;
}

public void setMarca(boolean marca) {

this.marca = marca;
}

public Nodo getNodoAntecesorDisjktra() {

return nodoAntecesorDisjktra;
}

public void setNodoAntecesorDisjktra(Nodo nodoAntecesorDisjktra) {

this.nodoAntecesorDisjktra = nodoAntecesorDisjktra;
}

}
___________________________________________________________________________________
____________________
package operaciones;

import java.awt.Color;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import objetos.Arista;
import objetos.Enlace;
import objetos.Grafo;
import objetos.Nodo;

public class Disjktra {

Grafo grafo;
ListaNodo listaNodosAdyacentes;
ArrayList<Arista> aux = new ArrayList<Arista>();
public Disjktra(Grafo grafo){
this.grafo = grafo;
listaNodosAdyacentes = new ListaNodo();
}
private void llenarConAdyacentes(Nodo nodo){
if(nodo != null){
ArrayList<Enlace> listaAux = nodo.getListaNodoAdyacente();
if(listaAux != null){
for(Enlace enlace:listaAux){
Nodo aux2 = enlace.getNodo();
if(!aux2.isMarca()){

if(listaNodosAdyacentes.isContenido(aux2)){
int longitud = nodo.getLongitudCamino() +
enlace.getArista().getPeso();
if(aux2.getLongitudCamino() > longitud){
aux2.setLongitudCamino(longitud);
aux2.setNodoAntecesorDisjktra(nodo);
}
}else{
aux2.setLongitudCamino(nodo.getLongitudCamino() +
enlace.getArista().getPeso());
aux2.setNodoAntecesorDisjktra(nodo);
 listaNodosAdyacentes.add(aux2);
}

}
}
}
}
}
public void ejecutar(Nodo nodoInicio){
nodoInicio.setLongitudCamino(0);
if(nodoInicio != null){
listaNodosAdyacentes = new ListaNodo();
listaNodosAdyacentes.add(nodoInicio);
while(!listaNodosAdyacentes.isEmpty()){
Nodo menor = listaNodosAdyacentes.buscarMenor();
menor.setMarca(true);
listaNodosAdyacentes.remove(menor);
llenarConAdyacentes(menor);
}
}
}

private void rutaCorta(Nodo nodoFinal){

aux.clear();
Nodo nAux = nodoFinal;
while(nAux.getNodoAntecesorDisjktra() != null){
// aux.add(grafo.getArista(nAux.getCapital().getNombreCiudad(),
// nAux.getNodoAntecesorDisjktra().getCapital().getNombreCiudad()));
aux.add(grafo.getArista(nAux,
nAux.getNodoAntecesorDisjktra()));
nAux = nAux.getNodoAntecesorDisjktra();
}

}
public void marcarRutaCorta(Nodo nodoFinal,Color color){
if(nodoFinal != null){
rutaCorta(nodoFinal);
for(int i = 0;i < aux.size();i++){
if(!aux.isEmpty()){
aux.get(i).getLineaQuebrada().setColor(color);
aux.get(i).getLineaQuebrada().setGrosorLinea(4);
}
}
}
}

}
___________________________________________________________________________________
____________________
package operaciones;

import java.util.ArrayList;
import objetos.Nodo;

public class ListaNodo extends ArrayList<Nodo>{

public ListaNodo(){
super();
}
 public Nodo buscarMenor(){
Nodo aux = new Nodo();
aux.setLongitudCamino(9999999);

for(Nodo nodo:this){
if(nodo.getLongitudCamino() < aux.getLongitudCamino()){
aux = nodo;
}
}

return aux;
}
public boolean isContenido(Nodo nodo){
boolean retornado = false;
for(Nodo n:this){
if(n == nodo){
retornado = true;
}
}
return retornado;
}
}
___________________________________________________________________________________
_______________________
package ventana;

import java.awt.Color;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import objetos.*;
import operaciones.Disjktra;

public class Gui extends javax.swing.JFrame {

Grafo grafo = new Grafo();
Nodo nodoInicio = null;
Nodo nodoFin = null;
/**
* Creamos el form
*/
public Gui() {
initComponents();
}

@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">

private void initComponents() {

jPanel2 = new javax.swing.JPanel();

jPanel1 = new javax.swing.JPanel();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder(null,
"Algoritmo de Dijkstra", javax.swing.border.TitledBorder.CENTER,
javax.swing.border.TitledBorder.DEFAULT_POSITION, new java.awt.Font("Tahoma", 1,
18))); // NOI18N
 jPanel2.setFont(new java.awt.Font("Tahoma", 0, 12)); // NOI18N

jPanel1.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
jPanel1MouseClicked(evt);
}
});

javax.swing.GroupLayout jPanel1Layout = new

javax.swing.GroupLayout(jPanel1);
jPanel1.setLayout(jPanel1Layout);
jPanel1Layout.setHorizontalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 629, Short.MAX_VALUE)
);
jPanel1Layout.setVerticalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 409, Short.MAX_VALUE)
);

javax.swing.GroupLayout jPanel2Layout = new

javax.swing.GroupLayout(jPanel2);
jPanel2.setLayout(jPanel2Layout);
jPanel2Layout.setHorizontalGroup(

jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel2Layout.createSequentialGroup()
.addContainerGap()
.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addContainerGap())
);
jPanel2Layout.setVerticalGroup(

jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel2Layout.createSequentialGroup()
.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addContainerGap())
);

javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
);

jPanel2.getAccessibleContext().setAccessibleName("Grafo Caminos Minimos");

 pack();
}// </editor-fold>
public void dibujarGrafo(){
jPanel1.paint(jPanel1.getGraphics());
dibujarArista();
dibujarNodos();
}
public void dibujarNodos(){
ArrayList<Nodo> listaNodo = grafo.getListaNodos();
for(Nodo nodo:listaNodo){
nodo.getCirculo().dibujarCirculo(jPanel1.getGraphics());
}
}
public void dibujarArista(){
ArrayList<Nodo> listaNodo = grafo.getListaNodos();
for(Nodo nodo:listaNodo){
ArrayList<Enlace> listaEnlace = nodo.getListaNodoAdyacente();
if(listaEnlace != null){
for(Enlace enlace:listaEnlace){

enlace.getArista().getLineaQuebrada().dibujarLineaQuebrada(jPanel1.getGraphics());
}
}
}
}
private int ingresarPeso(){
String peso = JOptionPane.showInputDialog("Digite la distancia entre
puntos");
int intPeso = 0;
try{
intPeso = Integer.parseInt(peso);
}catch(Exception ex){
intPeso = ingresarPeso();
}
return intPeso;
}

private void eliminarNodo(int x,int y){

if(grafo.buscarNodo(x, y)!=null){//si se hace clic sobre un nodo
Nodo temp = grafo.buscarNodo(x, y);
grafo.eliminarAristasEntrante(temp);
if(grafo.eliminarNodo(temp)){
JOptionPane.showMessageDialog(null,"Eliminado");
dibujarGrafo();
}

}
}

private void jPanel1MouseClicked(java.awt.event.MouseEvent evt) {

int x = evt.getX();
int y = evt.getY();
if(evt.isMetaDown()){
// eliminarNodo(x, y);
// JOptionPane.showMessageDialog(this,"Clic derecho");
if(grafo.buscarNodo(x, y)!=null){//si se hace clic sobre un nodo
if(nodoInicio == null){
 grafo.reiniciarGrafoParaDisjktra();
grafo.reiniciarColores();
nodoInicio = grafo.buscarNodo(x, y);//nodoInicio lo pongo a apuntar
al nodo donde hice clic
nodoInicio.getCirculo().setColor(Color.red);//Lo hago cambiar de
color
// JOptionPane.showMessageDialog(null,"Seleccione otro nodo para
crear una arista");
}else{//si nodoInicio ya estaba apunto a un nodo, lo preparo para crear
arista
nodoFin = grafo.buscarNodo(x, y);
Disjktra disjktra = new Disjktra(grafo);
disjktra.ejecutar(nodoInicio);
disjktra.marcarRutaCorta(nodoFin, Color.red);
// crearArista();
//
// nodoInicio.getCirculo().setColor(Color.yellow);//lo regreso a su
color original
//
nodoInicio = null;//null para poder crear mas arista
nodoFin = null;//null para poder crear mas arista
}
}

}else{
if(grafo.buscarNodo(x, y)!=null){//si se hace clic sobre un nodo
if(nodoInicio == null){
nodoInicio = grafo.buscarNodo(x, y);//nodoInicio lo pongo a apuntar
al nodo donde hice clic
nodoInicio.getCirculo().setColor(Color.red);//Lo hago cambiar de
color
// JOptionPane.showMessageDialog(null,"Seleccione otro nodo para
crear una arista");
}else{//si nodoInicio ya estaba apunto a un nodo, lo preparo para crear
arista
nodoFin = grafo.buscarNodo(x, y);
crearArista();

nodoInicio.getCirculo().setColor(Color.yellow);//lo regreso a su
color original

nodoInicio = null;//null para poder crear mas arista

nodoFin = null;//null para poder crear mas arista
}
}else{//Si no he hecho clic sobre un nodo
crearNodo(x, y);//creo un nodo apartir de unas coordenadas
}
}
dibujarGrafo();
}

private void crearArista(){

int intPeso = ingresarPeso();
Arista arista = new Arista();
arista.setPeso(intPeso);
Coordenadas c = new Coordenadas(100000,100000);
c.addCoordenada(nodoInicio.getCirculo().getX() +
(nodoInicio.getCirculo().getDiametro()/2),nodoInicio.getCirculo().getY() +
(nodoInicio.getCirculo().getDiametro()/2));
c.addCoordenada(nodoFin.getCirculo().getX() +
(nodoInicio.getCirculo().getDiametro()/2),nodoFin.getCirculo().getY() +
(nodoInicio.getCirculo().getDiametro()/2));
LineaQuebrada lq = new LineaQuebrada(c);
arista.setLineaQuebrada(lq);
grafo.crearEnlacesNoDirigido(nodoInicio, nodoFin,arista);

private void crearNodo(int x, int y){

Coordenadas c = new Coordenadas(100000,100000, x, y);
String dato = JOptionPane.showInputDialog("Digite un dato o Nombre de
la coordenada");
if(dato != null){
dato = dato.toUpperCase();//por que lo quiero todo en mayusculas
Nodo nodo = new Nodo(dato,c);
nodo.getCirculo().setDiametro(12);
nodo.getCirculo().setEtiqueta(nodo.getDato()+"");
if(grafo.adjuntarNodo(nodo)){
nodo.getCirculo().dibujarCirculo(jPanel1.getGraphics());
}else{
}
nodoInicio = null;
nodoFin = null;
}
}

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/*
* Set the Nimbus look and feel
*/
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code
(optional) ">
/*
* If Nimbus (introduced in Java SE 6) is not available, stay with the
* default look and feel. For details see
* http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(Gui.class.getName()).log(java.util.logging.Level
.SEVERE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(Gui.class.getName()).log(java.util.logging.Level
.SEVERE, null, ex);
 } catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(Gui.class.getName()).log(java.util.logging.Level
.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(Gui.class.getName()).log(java.util.logging.Level
.SEVERE, null, ex);
}
//</editor-fold>

/*
* Create and display the form
*/
java.awt.EventQueue.invokeLater(new Runnable() {

@Override
public void run() {
new Gui().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
// End of variables declaration
}