public void calcular(boolean diagonales) 
    {
        nodosEvaluados= new HashSet<>(); //set de nodos evaluados
        PriorityQueue<Nodo> nodosPorEvaluar = new PriorityQueue<>();//set de nodos por evaluar, contiene inicialmente al nodo inicial

        inicio.setFuncionG(0); //costo desde el inicio hasta el mejor camino conocido
        inicio.setFuncionHeursitica(calcularHeuristica(inicio, destino,diagonales));
        nodosPorEvaluar.add(inicio);
        

        int contadorIteraciones=0;
        while (!nodosPorEvaluar.isEmpty()) {
            
            Nodo actual = nodosPorEvaluar.poll();//obtener el nodo con menor funcion f

            if (actual.equals(destino)) 
            {  
                System.out.println("Iteraciones totales-> " + contadorIteraciones);
                System.out.println("Costo Total-> " + actual.getFuncionG()+actual.getFuncionHeursitica());
                reconstruirCamino(actual);
                break;
            }
            System.out.println("nodos por evaluar (frontera)"+ contadorIteraciones);
            System.out.println(nodosPorEvaluar);
            System.out.println("nodos evaluados");
            System.out.println(nodosEvaluados);
            nodosPorEvaluar.remove(actual);
            nodosEvaluados.add(actual);

            
            for (Nodo adyacente : actual.getNodosAdyacente(diagonales)) {
                /************************************
                int contN = 0;
                int diagonalN = arregloDiagonales.indexOf(contN);
                adyacente.setDistribuicion(diagonalN);
                contN++;
                ***********************************/
          
                boolean adyacenteIsMejor;
                if (nodosEvaluados.contains(adyacente))
                    continue; //se salta una iteracion
                

                if (!adyacente.isObstaculo()) {
                    double nuevoCosto = actual.getFuncionG() + getDistanciaEntre(actual, adyacente);
                    
                    if (!nodosPorEvaluar.contains(adyacente)){
                        //Collections.sort(nodosPorEvaluar);
                        //equivale a cambiar la prioridad a una cola
                        nodosPorEvaluar.add(adyacente);
                        adyacenteIsMejor = true;
                    }
                    else if (nuevoCosto < adyacente.getFuncionG())
                        adyacenteIsMejor = true;
                    else{
                        adyacenteIsMejor =false;
                        //nodosPorEvaluar.remove(adyacente);
                    }
                    if (adyacenteIsMejor){
                        adyacente.setRaiz(actual); //añadir el camino
                        //System.out.println("n: " + nuevoCosto);
                        adyacente.setFuncionG(nuevoCosto);
                        adyacente.setFuncionHeursitica(calcularHeuristica(adyacente, destino,diagonales));
                    }
                }
            }//cierra for adyacente
            contadorIteraciones++;
        }//cierra while
    }//cierra calcular