pgrouting::contraction::Pgr_contract< G > Class Template Reference

#include "pgr_contract.hpp"

Public Member Functions
	Pgr_contract (G &graph, Identifiers< V > forbidden_vertices, std::vector< int64_t > contraction_order, int64_t max_cycles)

Private Types
typedef G::V	V

Private Member Functions
void	one_cycle (G &graph, int64_t kind, Identifiers< V > &forbidden_vertices)
void	perform_deadEnd (G &graph, Identifiers< V > forbidden_vertices)
void	perform_linear (G &graph, Identifiers< V > &forbidden_vertices)

Detailed Description

template<class G>
class pgrouting::contraction::Pgr_contract< G >

Definition at line 49 of file pgr_contract.hpp.

Member Typedef Documentation

V

template<class G >

typedef G::V pgrouting::contraction::Pgr_contract< G >::V

private

Definition at line 50 of file pgr_contract.hpp.

Constructor & Destructor Documentation

Pgr_contract()

template<class G >

pgrouting::contraction::Pgr_contract< G >::Pgr_contract ( G &  graph, Identifiers< V >  forbidden_vertices, std::vector< int64_t >  contraction_order, int64_t  max_cycles  )

inline

Definition at line 53 of file pgr_contract.hpp.

              {
        std::deque<int64_t> contract_order;
        //  push -1 to indicate the start of the queue
        contract_order.push_back(-1);
        contract_order.insert(
                contract_order.end(),
                contraction_order.begin(), contraction_order.end());
        for (int64_t i = 0; i < max_cycles; ++i) {
            int64_t front = contract_order.front();
            contract_order.pop_front();
            contract_order.push_back(front);
            auto kind = contract_order.front();
            while (kind != -1) {
                one_cycle(graph, kind, forbidden_vertices);
                contract_order.pop_front();
                contract_order.push_back(front);
                kind = contract_order.front();
            }
        }
    }

References pgrouting::contraction::Pgr_contract< G >::one_cycle().

Member Function Documentation

one_cycle()

template<class G >

void pgrouting::contraction::Pgr_contract< G >::one_cycle ( G &  graph, int64_t  kind, Identifiers< V > &  forbidden_vertices  )

inlineprivate

Definition at line 81 of file pgr_contract.hpp.

                                                {
        switch (kind) {
            case -1:
                pgassert(false);
                break;
 
            case 1:
                perform_deadEnd(graph, forbidden_vertices);
                break;
 
 
            case 2:
                perform_linear(graph, forbidden_vertices);
                break;
            default:
                pgassert(false);
                break;
        }
    }

References pgrouting::contraction::Pgr_contract< G >::perform_deadEnd(), pgrouting::contraction::Pgr_contract< G >::perform_linear(), and pgassert.

Referenced by pgrouting::contraction::Pgr_contract< G >::Pgr_contract().

perform_deadEnd()

template<class G >

void pgrouting::contraction::Pgr_contract< G >::perform_deadEnd ( G &  graph, Identifiers< V >  forbidden_vertices  )

inlineprivate

Definition at line 104 of file pgr_contract.hpp.

                                               {
        Pgr_deadend<G> deadendContractor;
        deadendContractor.setForbiddenVertices(forbidden_vertices);
 
        deadendContractor.calculateVertices(graph);
        try {
            deadendContractor.doContraction(graph);
        }
        catch ( ... ) {
            throw;
        }
    }

References pgrouting::contraction::Pgr_deadend< G >::calculateVertices(), pgrouting::contraction::Pgr_deadend< G >::doContraction(), and pgrouting::contraction::Pgr_deadend< G >::setForbiddenVertices().

Referenced by pgrouting::contraction::Pgr_contract< G >::one_cycle().

perform_linear()

template<class G >

void pgrouting::contraction::Pgr_contract< G >::perform_linear ( G &  graph, Identifiers< V > &  forbidden_vertices  )

inlineprivate

Definition at line 119 of file pgr_contract.hpp.

                                                {
        Pgr_linear<G> linearContractor;
        try {
            linearContractor(graph, forbidden_vertices);
        }
        catch ( ... ) {
            throw;
        }
    }

Referenced by pgrouting::contraction::Pgr_contract< G >::one_cycle().

---

The documentation for this class was generated from the following file:

• pgr_contract.hpp