Ticket #13474: Boost Betweennness Centrality .cpp

#include <string>
#include <iostream>
#include <fstream>
#include <sstream>

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphviz.hpp>

#include <boost/graph/bc_clustering.hpp>
#include <boost/graph/iteration_macros.hpp>


// Graph edge properties (bundled properties)
struct EdgeProperties
{
        int weight;
};

typedef boost::property<boost::edge_weight_t, float> EdgeWeightProperty;

typedef boost::adjacency_list< boost::setS, boost::vecS, boost::undirectedS, boost::no_property, EdgeWeightProperty > Graph;

typedef Graph::vertex_descriptor Vertex;
typedef Graph::edge_descriptor Edge;

void WriteGraph(const Graph& g, const std::string& filename);

int addition(int a, int b);
int betweenness(int*, int*, int);

int main()//std::vector<int> arr)
{
        //provide array of connections from graph
        //from https://www.google.co.uk/search?q=between+centrality+calculation&client=firefox-b-ab&dcr=0&source=lnms&tbm=isch&sa=X&ved=0ahUKEwjeg8W7tdvZAhXMBZoKHbEnCjkQ_AUICigB&biw=1376&bih=692#imgrc=H9wvPMTEbg6bKM:
                int arr [] = { 1,2, 1,3, 2,3, 3,4, 3,5, 2,5, 5,7, 5,6 };
                //weights of the above connections
                int arr_weights[] = { 10,10,10,10,10,1,10,10};
                int size_nodes = 8;
                int a;
                int out = 1;
                a = betweenness(arr, arr_weights, size_nodes);//works

        return 0;
}

int findMax(int array[], int arraySize) {
        int maxPosition = 0;     //assume the first element is maximum
        for (int i = 1; i < arraySize; i++)
                if (array[i] > array[maxPosition]) //compare the current element with the known max
                        maxPosition = i;   //update maxPosition
        return array[maxPosition];
}

int betweenness(int *param, int *weights, int size_nodes)
{

        int ii = boost::lexical_cast<int>("1");
        double max_centrality = 14;

        //// Create a graph
        Graph g;
        int paramSize = size_nodes;

        static int Vert[50000000];

        int biggest = findMax(param, 16);

        //create the vetrices
        for (int a1=0; a1 < biggest+1; a1++)
        {
                Vert[a1] = boost::add_vertex(g);
        }

        //create the edges (with the given weights included)
        for (int a2=0; a2 < paramSize; a2++)
        {
                //EdgeWeightProperty weight0 = 5;
                boost::add_edge(Vert[param[a2*2]],Vert[param[a2*2+1]], EdgeWeightProperty(weights[a2]),  g);
        }


        // Define VertexCentralityMap
        typedef boost::property_map< Graph, boost::vertex_index_t>::type VertexIndexMap;



        VertexIndexMap v_index = get(boost::vertex_index, g);
        std::vector< double > v_centrality_vec(boost::num_vertices(g), 0.0);

        // Create the external property map
        boost::iterator_property_map< std::vector< double >::iterator, VertexIndexMap >
                v_centrality_map(v_centrality_vec.begin(), v_index);




        // Write to graphviz -> illustrate the graph via 'neato -Tps before.dot > before.ps'
        WriteGraph(g, "before.dot");

        // Calculate the vertex and edge centralites
        // Can be used to get an initial impression about the edge centrality values for the graph
        //brandes_betweenness_centrality( g, v_centrality_map, e_centrality_map );
        brandes_betweenness_centrality(g, v_centrality_map);


        //BGL_FORALL_VERTICES(vertex, g, Graph)
        for (int vertex=1;vertex<size_nodes;vertex++)
        {
                std::cout << vertex << ": " << v_centrality_map[vertex] << std::endl;
        }

        WriteGraph(g, "after.dot");

                return 0;
}

void WriteGraph(const Graph& g, const std::string& filename)
{
        std::ofstream graphStream;
        graphStream.open(filename.c_str());
        boost::write_graphviz(graphStream, g);
        graphStream.close();
}