#include <FPGATrackSimGNNRoadMakerTool.h>

Inheritance diagram for JunctionAwareVisitor:

Collaboration diagram for JunctionAwareVisitor:

Public Member Functions
	JunctionAwareVisitor (int &current, std::vector< int > &in_control_vars, std::vector< std::vector< int >> &in_comps, std::unordered_map< Vertex, std::vector< Vertex >> &in_pred_map)

template<typename VertexT , typename GraphT >
void	discover_vertex (VertexT v, const GraphT &g)

template<typename EdgeT , typename GraphT >
void	examine_edge (EdgeT e, const GraphT &g)

Private Attributes
int &	m_current_comp

std::vector< int > &	m_control_vars

std::vector< std::vector< int > > &	m_components

std::unordered_map< Vertex, std::vector< Vertex > > &	m_pred_map

int	m_initial_comp

int	m_n_iter = 1

Detailed Description

Definition at line 111 of file FPGATrackSimGNNRoadMakerTool.h.

Constructor & Destructor Documentation

◆ JunctionAwareVisitor()

JunctionAwareVisitor::JunctionAwareVisitor	(	int &	current,
		std::vector< int > &	in_control_vars,
		std::vector< std::vector< int >> &	in_comps,
		std::unordered_map< Vertex, std::vector< Vertex >> &	in_pred_map
	)

Definition at line 284 of file FPGATrackSimGNNRoadMakerTool.cxx.

                                                                                                      :
   m_current_comp(in_current), m_control_vars(in_control_vars), m_components(in_comps),
   m_pred_map(in_pred_map), m_initial_comp(in_current) {}

Member Function Documentation

◆ discover_vertex()

template<typename VertexT , typename GraphT >

void JunctionAwareVisitor::discover_vertex	(	VertexT	v,
		const GraphT &	g
	)

Definition at line 290 of file FPGATrackSimGNNRoadMakerTool.cxx.

 {
     if (m_control_vars[v] == -1){
         m_control_vars[v] = boost:: out_degree(v,g) < 2 ? 1 : -2; // -2 labels junctions before they are transversed
         m_components[v].push_back(m_current_comp);
     }
 }

◆ examine_edge()

template<typename EdgeT , typename GraphT >

void JunctionAwareVisitor::examine_edge	(	EdgeT	e,
		const GraphT &	g
	)

Definition at line 299 of file FPGATrackSimGNNRoadMakerTool.cxx.

 {
     auto src_node = source(e,g);
     auto tar_node = target(e,g);
     m_pred_map[tar_node].push_back(src_node);
  
     std::vector<int> src_comp; // Store the components of the source that need to be tracked
  
     for(int comp : m_components[src_node]){
         if(comp >= m_initial_comp && 
            std::find(m_components[tar_node].begin(), m_components[tar_node].end(), comp) == m_components[tar_node].end()){
             src_comp.push_back(comp); // Components of source node not in target
         }
     }
  
     // If source node has multiple in-edges, add the components from its predecessors
     if (boost::in_degree(src_node, g) > 1){
         auto in_edges = boost::in_edges(src_node, g);
         for (auto it = in_edges.first; it != in_edges.second; ++it){
             auto edge_src = source(*it, g);
             for (int comp : m_components[edge_src]){
                 if((comp >= m_initial_comp) && (std::find(src_comp.begin(), src_comp.end(), comp) == src_comp.end()) &&
                    (std::find(m_components[tar_node].begin(), m_components[tar_node].end(), comp) == m_components[tar_node].end())){
                     src_comp.push_back(comp);
                 }
             }
         }
     }
  
     // No junction case
     if (m_control_vars[src_node] == 1){
         m_components[tar_node].insert(m_components[tar_node].end(), src_comp.begin(), src_comp.end());
         m_control_vars[tar_node] = boost::out_degree(tar_node, g) < 2 ? 1 : -2;
     }
  
     // First time visiting a junction
     else if (m_control_vars[src_node] == -2){
         m_components[tar_node].insert(m_components[tar_node].end(), src_comp.begin(), src_comp.end());
         m_control_vars[tar_node] = boost::out_degree(tar_node, g) < 2 ? 1 : -2;
         m_control_vars[src_node] = 2; // 2 labels a junction after the first visit to it
         m_n_iter = src_comp.size(); // Number of indices to add to each component going out of this junction
     }
  
     // Going through a junction already visited
     else if (m_control_vars[src_node] == 2){
         for(int i = 0; i != m_n_iter; ++i){
             ++m_current_comp;
             m_components[tar_node].push_back(m_current_comp);
             m_control_vars[tar_node] = boost::out_degree(tar_node, g) < 2 ? 1 : -2;
             // Backtrace the node's predecessors to propagate the new label
             std::unordered_set<Vertex> visited;
             std::function<void(Vertex)> backtrace = [&](Vertex node){
                 if(visited.count(node)) return;
                 visited.insert(node);
                 const auto& node_comps = m_components[node];
                 if((std::find(node_comps.begin(), node_comps.end(), m_current_comp) == node_comps.end()) &&
                    (src_comp.empty() || std::find(node_comps.begin(), node_comps.end(), src_comp[i]) == node_comps.end())){ // Backpropagate with junction awareness
                     m_components[node].push_back(m_current_comp);
                 }
                 for (const auto& pred : m_pred_map[node]){
                     backtrace(pred);
                 }
             };
             backtrace(tar_node);
         }
     }
 }