anonymous_namespace{contractGraph_driver.cpp} Namespace Reference

Functions
template<typename G >
Identifiers< int64_t >	get_modified_vertices (const G &graph)
	vertices with at least one contracted vertex More...
template<typename G >
void	get_postgres_result (G &graph, contracted_rt **return_tuples, size_t *count)
template<typename G >
std::vector< typename G::E >	get_shortcuts (const G &graph)
	vertices with at least one contracted vertex More...
template<typename G >
void	process_contraction (G &graph, const std::vector< pgr_edge_t > &edges, const std::vector< int64_t > &forbidden_vertices, const std::vector< int64_t > &contraction_order, int64_t max_cycles)

Function Documentation

get_modified_vertices()

template<typename G >

Identifiers<int64_t> anonymous_namespace{contractGraph_driver.cpp}::get_modified_vertices

(

const G &

graph

)

vertices with at least one contracted vertex

Returns

The vids Identifiers with at least one contracted vertex

Definition at line 51 of file contractGraph_driver.cpp.

                                                           {
    Identifiers<int64_t> vids;
    for (auto v : boost::make_iterator_range(boost::vertices(graph.graph))) {
        if (graph[v].has_contracted_vertices()) {
            vids += graph[v].id;
        }
    }
    return vids;
}

Referenced by get_postgres_result().

get_postgres_result()

template<typename G >

void anonymous_namespace{contractGraph_driver.cpp}::get_postgres_result	(	G &	graph,
		contracted_rt **	return_tuples,
		size_t *	count
	)

Definition at line 111 of file contractGraph_driver.cpp.

                       {
    auto modified_vertices(get_modified_vertices(graph));
    auto shortcut_edges(get_shortcuts(graph));
 
    (*count) = modified_vertices.size() + shortcut_edges.size();
    (*return_tuples) = pgr_alloc((*count), (*return_tuples));
    size_t sequence = 0;
 
    for (const auto id : modified_vertices) {
        auto v = graph.get_V(id);
        int64_t* contracted_vertices = NULL;
        auto vids = graph[v].contracted_vertices();
 
        contracted_vertices = pgr_alloc(vids.size(), contracted_vertices);
 
        int count = 0;
        for (const auto id : vids) {
            contracted_vertices[count++] = id;
        }
        (*return_tuples)[sequence] = {
            id,
            const_cast<char*>("v"),
            -1, -1, -1.00,
            contracted_vertices,
            count};
 
        ++sequence;
    }
 
    int64_t eid = 0;
    for (auto e : shortcut_edges) {
        auto edge = graph[e];
        int64_t* contracted_vertices = NULL;
 
        const auto vids(edge.contracted_vertices());
        pgassert(!vids.empty());
 
        contracted_vertices = pgr_alloc(vids.size(), contracted_vertices);
        int count = 0;
        for (const auto vid : vids) {
            contracted_vertices[count++] = vid;
        }
        (*return_tuples)[sequence] = {
            --eid,
            const_cast<char*>("e"),
            edge.source, edge.target, edge.cost,
            contracted_vertices, count};
        ++sequence;
    }
}

References edge::cost, get_modified_vertices(), get_shortcuts(), pgassert, pgr_alloc(), edge::source, and edge::target.

get_shortcuts()

template<typename G >

std::vector<typename G::E> anonymous_namespace{contractGraph_driver.cpp}::get_shortcuts

(

const G &

graph

)

vertices with at least one contracted vertex

Returns

The vids Identifiers with at least one contracted vertex

Definition at line 66 of file contractGraph_driver.cpp.

                                                     {
    using E = typename G::E;
    Identifiers<E> eids;
    for (auto e : boost::make_iterator_range(boost::edges(graph.graph))) {
        if (graph[e].id < 0) {
            eids += e;
            pgassert(!graph[e].contracted_vertices().empty());
        } else {
            pgassert(graph[e].contracted_vertices().empty());
        }
    }
    std::vector<E> o_eids(eids.begin(), eids.end());
    std::sort(o_eids.begin(), o_eids.end(),
            [&](E lhs, E rhs) {return -graph[lhs].id < -graph[rhs].id;});
    return o_eids;
}

References Identifiers< T >::begin(), Identifiers< T >::end(), and pgassert.

Referenced by get_postgres_result().

process_contraction()

template<typename G >

void anonymous_namespace{contractGraph_driver.cpp}::process_contraction	(	G &	graph,
		const std::vector< pgr_edge_t > &	edges,
		const std::vector< int64_t > &	forbidden_vertices,
		const std::vector< int64_t > &	contraction_order,
		int64_t	max_cycles
	)

Definition at line 85 of file contractGraph_driver.cpp.

                            {
    graph.insert_edges(edges);
    Identifiers<typename G::V> forbid_vertices;
    for (const auto &vertex : forbidden_vertices) {
        if (graph.has_vertex(vertex)) {
            forbid_vertices += graph.get_V(vertex);
        }
    }
 
    /*
     * Function call to get the contracted graph.
     */
    using Contract = pgrouting::contraction::Pgr_contract<G>;
    Contract result(
            graph,
            forbid_vertices,
            contraction_order,
            max_cycles);
}

Referenced by do_pgr_contractGraph().