Esempio n. 1
0
  void breadth_first_visit
    (const IncidenceGraph& g,
     typename graph_traits<IncidenceGraph>::vertex_descriptor s,
     const bgl_named_params<P, T, R>& params)
  {
    // The graph is passed by *const* reference so that graph adaptors
    // (temporaries) can be passed into this function. However, the
    // graph is not really const since we may write to property maps
    // of the graph.
    IncidenceGraph& ng = const_cast<IncidenceGraph&>(g);

    typedef graph_traits<IncidenceGraph> Traits;
    // Buffer default
    typedef typename Traits::vertex_descriptor vertex_descriptor;
    typedef boost::queue<vertex_descriptor> queue_t;
    queue_t Q;
    detail::wrap_ref<queue_t> Qref(Q);

    breadth_first_visit
      (ng, s,
       choose_param(get_param(params, buffer_param_t()), Qref).ref,
       choose_param(get_param(params, graph_visitor),
                    make_bfs_visitor(null_visitor())),
       choose_pmap(get_param(params, vertex_color), ng, vertex_color)
       );
  }
Esempio n. 2
0
 static void apply
 (VertexListGraph& g,
  typename graph_traits<VertexListGraph>::vertex_descriptor s,
  const bgl_named_params<P, T, R>& params,
  ColorMap color)
 {
   bfs_helper
     (g, s, color,
      choose_param(get_param(params, graph_visitor),
                   make_bfs_visitor(null_visitor())),
      params);
 }
Esempio n. 3
0
 static void apply
 (VertexListGraph& g,
  typename graph_traits<VertexListGraph>::vertex_descriptor s,
  EdgeType e,
  const bgl_named_params<P, T, R>& params,
  ColorMap color)
 {
   bfs_helper
     (g, s, e, color,
      choose_param(get_param(params, graph_visitor),
                   make_bfs_visitor(null_visitor())),
      params,
      boost::mpl::bool_<
      boost::is_base_and_derived<
      distributed_graph_tag,
      typename graph_traits<VertexListGraph>::traversal_category>::value>());
 }
Esempio n. 4
0
 static void apply
 (VertexListGraph& g,
  typename graph_traits<VertexListGraph>::vertex_descriptor s,
  const bgl_named_params<P, T, R>& params,
  detail::error_property_not_found)
 {
   std::vector<default_color_type> color_vec(num_vertices(g));
   default_color_type c = white_color;
   null_visitor null_vis;
   
   bfs_helper
     (g, s, 
      make_iterator_property_map
      (color_vec.begin(), 
       choose_const_pmap(get_param(params, vertex_index), 
                         g, vertex_index), c),
      choose_param(get_param(params, graph_visitor),
                   make_bfs_visitor(null_vis)),
      params);
 }
Esempio n. 5
0
static
depth findMinWidth(const NGHolder &h, const SpecialEdgeFilter &filter,
                   NFAVertex src) {
    if (isLeafNode(src, h)) {
        return depth::unreachable();
    }

    boost::filtered_graph<NFAGraph, SpecialEdgeFilter> g(h.g, filter);

    assert(hasCorrectlyNumberedVertices(h));
    const size_t num = num_vertices(h);
    vector<depth> distance(num, depth::unreachable());
    distance.at(g[src].index) = depth(0);

    auto index_map = get(&NFAGraphVertexProps::index, g);

    // Since we are interested in the single-source shortest paths on a graph
    // with the same weight on every edge, using BFS will be faster than
    // Dijkstra here.
    breadth_first_search(
        g, src,
        visitor(make_bfs_visitor(record_distances(
                    make_iterator_property_map(distance.begin(), index_map),
                    boost::on_tree_edge()))).vertex_index_map(index_map));

    DEBUG_PRINTF("d[accept]=%s, d[acceptEod]=%s\n",
                 distance.at(NODE_ACCEPT).str().c_str(),
                 distance.at(NODE_ACCEPT_EOD).str().c_str());

    depth d = min(distance.at(NODE_ACCEPT), distance.at(NODE_ACCEPT_EOD));

    if (d.is_unreachable()) {
        return d;
    }

    assert(d.is_finite());
    assert(d > depth(0));
    return d - depth(1);
}
Esempio n. 6
0
      static void apply
      (VertexListGraph& g,
       typename graph_traits<VertexListGraph>::vertex_descriptor s,
       EdgeType e,
       const bgl_named_params<P, T, R>& params,
       param_not_found)
      {
        null_visitor null_vis;

        bfs_helper
          (g, s, e,
           make_two_bit_color_map
           (num_vertices(g),
            choose_const_pmap(get_param(params, vertex_index),
                              g, vertex_index)),
           choose_param(get_param(params, graph_visitor),
                        make_bfs_visitor(null_vis)),
           params,
           boost::mpl::bool_<
           boost::is_base_and_derived<
           distributed_graph_tag,
           typename graph_traits<VertexListGraph>::traversal_category>::value>());
      }
 typename property_traits<CapacityEdgeMap>::value_type
 edmunds_karp_max_flow
   (Graph& g, 
    typename graph_traits<Graph>::vertex_descriptor src,
    typename graph_traits<Graph>::vertex_descriptor sink,
    CapacityEdgeMap cap, 
    ResidualCapacityEdgeMap res,
    ReverseEdgeMap rev, 
    ColorMap color, 
    PredEdgeMap pred)
 {
   typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
   typedef typename property_traits<ColorMap>::value_type ColorValue;
   typedef color_traits<ColorValue> Color;
   
   typename graph_traits<Graph>::vertex_iterator u_iter, u_end;
   typename graph_traits<Graph>::out_edge_iterator ei, e_end;
   for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
     for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
       res[*ei] = cap[*ei];
   
   color[sink] = Color::gray();
   while (color[sink] != Color::white()) {
     boost::queue<vertex_t> Q;
     breadth_first_search
       (detail::residual_graph(g, res), src, Q,
        make_bfs_visitor(record_edge_predecessors(pred, on_tree_edge())),
        color);
     if (color[sink] != Color::white())
       detail::augment(g, src, sink, pred, res, rev);
   } // while
   
   typename property_traits<CapacityEdgeMap>::value_type flow = 0;
   for (tie(ei, e_end) = out_edges(src, g); ei != e_end; ++ei)
     flow += (cap[*ei] - res[*ei]);
   return flow;
 } // edmunds_karp_max_flow()
Esempio n. 8
0
  OutputIterator
  sloan_ordering(Graph& g,
                 typename graph_traits<Graph>::vertex_descriptor s,
                 typename graph_traits<Graph>::vertex_descriptor e,
                 OutputIterator permutation, 
                 ColorMap color, 
                 DegreeMap degree, 
                 PriorityMap priority, 
                 Weight W1, 
                 Weight W2)
  {
    //typedef typename property_traits<DegreeMap>::value_type Degree;
    typedef typename property_traits<PriorityMap>::value_type Degree;
    typedef typename property_traits<ColorMap>::value_type ColorValue;
    typedef color_traits<ColorValue> Color;
    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    typedef typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter;
    typedef typename graph_traits<Graph>::vertices_size_type size_type;

    typedef typename property_map<Graph, vertex_index_t>::const_type VertexID;

    
    //Creating a std-vector for storing the distance from the end vertex in it
    typename std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(g), 0);
    
    //Wrap a property_map_iterator around the std::iterator
    boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, g)); 
    
    breadth_first_search
      (g, e, visitor
       (
           make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) )
        )
       );
    
    //Creating a property_map for the indices of a vertex
    typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, g);
    
    //Sets the color and priority to their initial status
    unsigned cdeg;    
    typename graph_traits<Graph>::vertex_iterator ui, ui_end;
    for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
    {
        put(color, *ui, Color::white());
        cdeg=get(degree, *ui)+1;
        put(priority, *ui, W1*dist[index_map[*ui]]-W2*cdeg );  
    }
    
    //Priority list
    typedef indirect_cmp<PriorityMap, std::greater<Degree> > Compare;
    Compare comp(priority);
    std::list<Vertex> priority_list;

    //Some more declarations
    typename graph_traits<Graph>::out_edge_iterator ei, ei_end, ei2, ei2_end;
    Vertex u, v, w;

    put(color, s, Color::green());      //Sets the color of the starting vertex to gray
    priority_list.push_front(s);                 //Puts s into the priority_list
    
    while ( !priority_list.empty() ) 
    {  
      priority_list.sort(comp);         //Orders the elements in the priority list in an ascending manner
      
      u = priority_list.front();           //Accesses the last element in the priority list
      priority_list.pop_front();               //Removes the last element in the priority list
      
      if(get(color, u) == Color::green() )
      {
        //for-loop over all out-edges of vertex u
        for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) 
        {
          v = target(*ei, g);
          
          put( priority, v, get(priority, v) + W2 ); //updates the priority
          
          if (get(color, v) == Color::white() )      //test if the vertex is inactive
          {
            put(color, v, Color::green() );        //giving the vertex a preactive status
            priority_list.push_front(v);                     //writing the vertex in the priority_queue
          }           
        }
      }
      
      //Here starts step 8
      *permutation++ = u;                      //Puts u to the first position in the permutation-vector
      put(color, u, Color::black() );          //Gives u an inactive status
      
      //for loop over all the adjacent vertices of u
      for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
        
        v = target(*ei, g);     
        
        if (get(color, v) == Color::green() ) {      //tests if the vertex is inactive
          
          put(color, v, Color::red() );        //giving the vertex an active status
          put(priority, v, get(priority, v)+W2);  //updates the priority        
          
          //for loop over alll adjacent vertices of v
          for (boost::tie(ei2, ei2_end) = out_edges(v, g); ei2 != ei2_end; ++ei2) {
            w = target(*ei2, g);
            
            if(get(color, w) != Color::black() ) {     //tests if vertex is postactive
              
              put(priority, w, get(priority, w)+W2);  //updates the priority
              
              if(get(color, w) == Color::white() ){
                
                put(color, w, Color::green() );   // gives the vertex a preactive status
                priority_list.push_front(w);           // puts the vertex into the priority queue
                
              } //end if
              
            } //end if
            
          } //end for
          
        } //end if
        
      } //end for
      
    } //end while
    
    
    return permutation;
  }  
Esempio n. 9
0
  typename graph_traits<Graph>::vertex_descriptor 
  sloan_start_end_vertices(Graph& G, 
                           typename graph_traits<Graph>::vertex_descriptor &s, 
                           ColorMap color, 
                           DegreeMap degree)
  {
    typedef typename property_traits<DegreeMap>::value_type Degree;
    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
    typedef typename std::vector< typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter;
    typedef typename graph_traits<Graph>::vertices_size_type size_type;
    
    typedef typename property_map<Graph, vertex_index_t>::const_type VertexID;
    
    s = *(vertices(G).first);
    Vertex e = s;
    Vertex i;
    unsigned my_degree = get(degree, s ); 
    unsigned dummy, h_i, h_s, w_i, w_e;
    bool new_start = true;
    unsigned maximum_degree = 0;
    
    //Creating a std-vector for storing the distance from the start vertex in dist
    std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(G), 0);

    //Wrap a property_map_iterator around the std::iterator
    boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, G));
    
    //Creating a property_map for the indices of a vertex
    typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, G);
    
    //Creating a priority queue
    typedef indirect_cmp<DegreeMap, std::greater<Degree> > Compare;
    Compare comp(degree);
    std::priority_queue<Vertex, std::vector<Vertex>, Compare> degree_queue(comp);
    
    //step 1
    //Scan for the vertex with the smallest degree and the maximum degree
    typename graph_traits<Graph>::vertex_iterator ui, ui_end;
    for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
    {
      dummy = get(degree, *ui);
      
      if(dummy < my_degree)
      {
        my_degree = dummy;
        s = *ui;
      }
      
      if(dummy > maximum_degree)
      {
        maximum_degree = dummy;
      }
    }
    //end 1
    
    do{  
      new_start = false;     //Setting the loop repetition status to false
      
      //step 2
      //initialize the the disance std-vector with 0
      for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0;
      
      //generating the RLS (rooted level structure)
      breadth_first_search
        (G, s, visitor
         (
           make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) )
           )
          );
      
      //end 2
      
      //step 3
      //calculating the depth of the RLS
      h_s = RLS_depth(dist);
      
      //step 4
      //pushing one node of each degree in an ascending manner into degree_queue
      std::vector<bool> shrink_trace(maximum_degree, false);
      for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
      {
        dummy = get(degree, *ui);
        
        if( (dist[index_map[*ui]] == h_s ) && ( !shrink_trace[ dummy ] ) )
        {
          degree_queue.push(*ui);
          shrink_trace[ dummy ] = true;
        }
      }
      
      //end 3 & 4

      
      // step 5
      // Initializing w
      w_e = (std::numeric_limits<unsigned>::max)();
      //end 5
      
      
      //step 6
      //Testing for termination
      while( !degree_queue.empty() )
      {
        i = degree_queue.top();       //getting the node with the lowest degree from the degree queue
        degree_queue.pop();           //ereasing the node with the lowest degree from the degree queue
        
        //generating a RLS          
        for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0;
        
        breadth_first_search
          (G, i, boost::visitor
           (
             make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) )
             )
            );
        
        //Calculating depth and width of the rooted level
        h_i = RLS_depth(dist);
        w_i = RLS_max_width(dist, h_i);
        
        //Testing for termination
        if( (h_i > h_s) && (w_i < w_e) ) 
        {
          h_s = h_i;
          s = i;
          while(!degree_queue.empty()) degree_queue.pop();
          new_start = true;         
        }
        else if(w_i < w_e)
        { 
          w_e = w_i;
          e = i;
        }
      }
      //end 6
        
    }while(new_start);
    
    return e;
  }
Esempio n. 10
0
void evaluateGeodesicDist(GridSpecs grid_specs, std::vector<Polygon_2> polygons,
                          std::vector<Point> ref_points, IOSpecs io_specs)
{

  // -- grid definition --
 
  // no. of rows and columns
  int no_rows, no_cols;
  no_rows = (int)grid_specs.getGridSpecs().at(0);
  no_cols = (int)grid_specs.getGridSpecs().at(1);

  // grid points
  int no_gpoints;
  no_gpoints = (no_rows*no_cols);

  // spatial locations of the grid points
  std::vector<Point_2> grid_points;


  // evaluating the spatial locations of the grid points
  initGrid(grid_specs, grid_points);



  //--

  // -- graph definition --

  //
  // note that two different graphs need to be considered:
  //
  // 1) effective graph -
  //    graph associated with the complementary domain;
  //    the nodes of this graph do not include the grid points
  //    associated with the polygon(s);
  //
  // 2) BGL graph -
  //    graph processed by the BGL library;
  //    this graph coincides with the grid;
  //    the nodes of this graph coincide the grid points;
  //    the nodes associated with the polygon(s) are nodes
  //    with no edges, i.e. they are nodes of degree zero;
  //
  //
  //  no. of nodes (effective graph) < no. of nodes (BGL graph)
  //  no. of edges (effective graph) = no. of edges (BGL graph)
  //


  // grid points IDs associated with the polygon(s)
  std::vector<Polygon_gp_id> gpoints_id_pgn;
  // grid points IDs associated with the graph
  std::vector<int> gpoints_id_graph;


  // project the data to the grid;
  // evaluate the grid points IDs associated with the polygon(s) and
  // those associated with the complementary domain (graph)
  projectDataToGrid(grid_points, polygons, gpoints_id_pgn, gpoints_id_graph);


  // no. of grid points associated with the polygon
  int no_gpoints_png = gpoints_id_pgn.at(0).size();
  // no. of grid points associated with the graph
  int no_gpoints_graph = gpoints_id_graph.size();

  // writing output file `Dreses.dat'
  std::string outfile_name_1("Dreses.dat");

  OutputProcess_Dreses out1(io_specs.getAbsolutePathName(outfile_name_1));
  out1.toOutput(ref_points, polygons,
                grid_specs, no_gpoints_png, no_gpoints_graph);


  grid_points.clear();
  polygons.clear();

  
  // names of the nodes (vertices)
  std::vector<std::string> node_names;
  // edges
  std::vector<Edge> edges;

  // evaluating the node names and the edges of the `effective graph'
  initGraph(grid_specs, gpoints_id_pgn, gpoints_id_graph, node_names, edges);


  gpoints_id_pgn.clear();
  gpoints_id_graph.clear();


  // number of edges
  int no_edges;
  no_edges = edges.size();

  // weights
  float* weights = new float[no_edges];

  for (int i=0; i<no_edges; i++) {
    weights[i] = grid_specs.getGridSpecs().at(2);
  }


  // BGL graph
  GridGraph g(edges.begin(), edges.end(), weights, no_gpoints);
  GridGraph g_copy(edges.begin(), edges.end(), weights, no_gpoints);


  //--
  #ifdef DEBUG_GRAPH

    std::cout << "\n>> debug - graph" << std::endl;

    std::cout << "no. of nodes (effective graph): " << node_names.size() << std::endl;
    std::cout << "no. of nodes (BGL graph): " << no_gpoints << std::endl;
    std::cout << "no. of edges: " << edges.size() << std::endl;
    write_graphviz(std::cout, g);

  #endif // DEBUG_GRAPH
  //--


  // parents of the nodes
  std::vector<vertex_descriptor> parents(num_vertices(g));

  // source node ID
  // note that node ID = (grid point ID - 1)
  int s_node_id;
  s_node_id = (getGridPointID(ref_points.at(0).first, ref_points.at(0).second, grid_specs) - 1);

  // source node
  vertex_descriptor s_node = vertex(s_node_id, g);
  // the parent of `s_node' is `s_node' (distance = 0)
  parents[s_node] = s_node;

  // distances from the source to each node
  // (including the null distances - i.e. the distance from the source to itself
  // and the distances from the source to the nodes of degree zero)
  vertices_size_type distances[no_gpoints];
  std::fill_n(distances, no_gpoints, 0);

  // evaluating the distances by using the Breadth-First Search (BFS) algorithm
  breadth_first_search(g,
                       s_node,
                       visitor(make_bfs_visitor(std::make_pair(record_distances(distances,
                                                                                on_tree_edge()),
                                                               std::make_pair(record_predecessors(&parents[0],
                                                                                                  on_tree_edge()),
                                                                              copy_graph(g_copy,
                                                                                         on_examine_edge())
                                                                             )
                                                              )
                                               )
                              )
                      );


  // writing output file `distances.dat'
  std::string outfile_name_2("distances.dat");

  OutputProcess_Distances out2(io_specs.getAbsolutePathName(outfile_name_2));
  out2.toOutput(grid_specs, no_gpoints, s_node_id, node_names, distances);


  delete [] weights;


}