Book keeping class for swapping orders between vehicles. More...

Namespaces
	algorithms

	alphashape

	bidirectional

	contraction

	details

	flow

	functions

	graph
	boost::graph simplified to pgRouting needs This class gives the handling basics of a boost::graph of kind G where G: can be an undirected graph or a directed graph.

	trsp

	tsp

	visitors

	vrp

	yen

Classes
class	Basic_edge

class	Basic_vertex

class	CH_edge

class	CH_vertex

class	compPathsLess

struct	found_goals
	exception for visitor termination More...

class	Identifier

class	Line_vertex

class	Pg_points_graph

class	Pgr_dijkstra

class	Pgr_messages

class	XY_vertex

Typedefs
typedef boost::adjacency_list< boost::listS, boost::vecS, boost::directedS >	BasicDirectedGraph

typedef boost::adjacency_list< boost::listS, boost::vecS, boost::undirectedS >	BasicUndirectedGraph

using	Bline = bg::model::linestring< Bpoint >

using	Blines = bg::model::multi_linestring< Bline >

using	Bpoint = bg::model::d2::point_xy< double >

using	Bpoints = bg::model::multi_point< Bpoint >

using	Bpoly = bg::model::polygon< Bpoint >

using	Bpolys = bg::model::multi_polygon< Bpoly >

typedef boost::property_map< CostFlowGraph, boost::edge_capacity_t >::type	Capacity

typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::directedS, boost::no_property, boost::property< boost::edge_capacity_t, double, boost::property< boost::edge_residual_capacity_t, double, boost::property< boost::edge_reverse_t, Traits::edge_descriptor, boost::property< boost::edge_weight_t, double > > > > >	CostFlowGraph

typedef boost::adjacency_list< boost::listS, boost::vecS, boost::directedS, boost::property< boost::vertex_index_t, int64_t, boost::property< boost::vertex_color_t, boost::default_color_type, boost::property< boost::vertex_distance_t, int64_t, boost::property< boost::vertex_predecessor_t, Traits::edge_descriptor > > > >, boost::property< boost::edge_capacity_t, int64_t, boost::property< boost::edge_residual_capacity_t, int64_t, boost::property< boost::edge_reverse_t, Traits::edge_descriptor > > > >	FlowGraph

typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::bidirectionalS, Line_vertex, Basic_edge >	LinearDirectedGraph
	Data type to handle graph -> lineGaph transformation. More...

typedef boost::property_map< CostFlowGraph, boost::edge_residual_capacity_t >::type	ResidualCapacity

typedef boost::property_map< CostFlowGraph, boost::edge_reverse_t >::type	Reversed

typedef boost::adjacency_list_traits< boost::vecS, boost::vecS, boost::directedS >	Traits

typedef boost::property_map< CostFlowGraph, boost::edge_weight_t >::type	Weight

Functions
size_t	check_vertices (std::vector< Basic_vertex > vertices)

size_t	check_vertices (std::vector< CH_vertex > vertices)

size_t	check_vertices (std::vector< XY_vertex > vertices)

std::vector< Basic_vertex >	extract_vertices (const pgr_edge_t *data_edges, size_t count)

std::vector< XY_vertex >	extract_vertices (const Pgr_edge_xy_t *data_edges, size_t count)

std::vector< Basic_vertex >	extract_vertices (const std::vector< Basic_vertex > &vertices, const pgr_edge_t *data_edges, size_t count)

std::vector< Basic_vertex >	extract_vertices (const std::vector< pgr_edge_t > &data_edges)

std::vector< XY_vertex >	extract_vertices (const std::vector< Pgr_edge_xy_t > &data_edges)

std::vector< Basic_vertex >	extract_vertices (std::vector< Basic_vertex > vertices, const pgr_edge_t *data_edges, size_t count)

std::vector< Basic_vertex >	extract_vertices (std::vector< Basic_vertex > vertices, const std::vector< pgr_edge_t > data_edges)

std::ostream &	operator<< (std::ostream &log, const Basic_vertex &v)

std::ostream &	operator<< (std::ostream &log, const Identifier &ident)

std::ostream &	operator<< (std::ostream &log, const XY_vertex &v)

std::ostream &	operator<< (std::ostream &os, const CH_edge &e)

std::ostream &	operator<< (std::ostream &os, const CH_vertex &v)

std::ostream &	operator<< (std::ostream &os, const Pg_points_graph &g)

template<class G >
Path	pgr_dijkstra (G &graph, int64_t source, int64_t target, bool only_cost=false)

template<class G >
std::deque< Path >	pgr_drivingDistance (G &graph, std::vector< int64_t > start_vids, double distance, bool equicost, std::ostringstream &log)

Detailed Description

Book keeping class for swapping orders between vehicles.

Typedef Documentation

◆ BasicDirectedGraph

typedef boost::adjacency_list<boost::listS, boost::vecS, boost::directedS> pgrouting::BasicDirectedGraph

Definition at line 50 of file pgr_maximumcardinalitymatching.hpp.

◆ BasicUndirectedGraph

typedef boost::adjacency_list<boost::listS, boost::vecS, boost::undirectedS> pgrouting::BasicUndirectedGraph

Definition at line 48 of file pgr_maximumcardinalitymatching.hpp.

◆ Bline

using pgrouting::Bline = typedef bg::model::linestring<Bpoint>

Definition at line 43 of file bline.hpp.

◆ Blines

using pgrouting::Blines = typedef bg::model::multi_linestring<Bline>

Definition at line 44 of file bline.hpp.

◆ Bpoint

typedef bg::model::d2::point_xy< double > pgrouting::Bpoint

Definition at line 40 of file bline.hpp.

◆ Bpoints

using pgrouting::Bpoints = typedef bg::model::multi_point<Bpoint>

Definition at line 41 of file bline.hpp.

◆ Bpoly

using pgrouting::Bpoly = typedef bg::model::polygon<Bpoint>

Definition at line 46 of file bline.hpp.

◆ Bpolys

using pgrouting::Bpolys = typedef bg::model::multi_polygon<Bpoly>

Definition at line 47 of file bline.hpp.

◆ Capacity

typedef boost::property_map< CostFlowGraph, boost::edge_capacity_t >::type pgrouting::Capacity

Definition at line 51 of file pgr_costFlowGraph.hpp.

◆ CostFlowGraph

typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::directedS, boost::no_property, boost::property < boost::edge_capacity_t, double, boost::property < boost::edge_residual_capacity_t, double, boost::property < boost::edge_reverse_t, Traits::edge_descriptor, boost::property < boost::edge_weight_t, double> > > > > pgrouting::CostFlowGraph

Definition at line 49 of file pgr_costFlowGraph.hpp.

◆ DirectedGraph

typedef graph::Pgr_base_graph<boost::adjacency_list < boost::vecS, boost::vecS, boost::bidirectionalS, Basic_vertex, Basic_edge >, Basic_vertex, Basic_edge > pgrouting::DirectedGraph

Definition at line 192 of file pgr_base_graph.hpp.

◆ FlowGraph

typedef boost::adjacency_list<boost::listS, boost::vecS, boost::directedS, boost::property<boost::vertex_index_t, int64_t, boost::property<boost::vertex_color_t, boost::default_color_type, boost::property<boost::vertex_distance_t, int64_t, boost::property<boost::vertex_predecessor_t, Traits::edge_descriptor> > > >, boost::property<boost::edge_capacity_t, int64_t, boost::property<boost::edge_residual_capacity_t, int64_t, boost::property<boost::edge_reverse_t, Traits::edge_descriptor> > > > pgrouting::FlowGraph

Definition at line 50 of file pgr_flowgraph.hpp.

◆ LinearDirectedGraph

typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::bidirectionalS, Line_vertex, Basic_edge > pgrouting::LinearDirectedGraph

Data type to handle graph -> lineGaph transformation.

Usage:

pgrouting::graph::Pgr_lineGraphFull<
     pgrouting::LinearDirectedGraph,  // using here
     pgrouting::Line_vertex,
     pgrouting::Basic_edge > line(graphType::DIRECTED);
 
pgrouting::graph::Pgr_lineGraph<
     pgrouting::LinearDirectedGraph,  // using here
     pgrouting::Line_vertex,
     pgrouting::Basic_edge > line(graphType::DIRECTED);

Definition at line 55 of file linear_directed_graph.h.

◆ ResidualCapacity

typedef boost::property_map< CostFlowGraph, boost::edge_residual_capacity_t >::type pgrouting::ResidualCapacity

Definition at line 53 of file pgr_costFlowGraph.hpp.

◆ Reversed

typedef boost::property_map< CostFlowGraph, boost::edge_reverse_t >::type pgrouting::Reversed

Definition at line 57 of file pgr_costFlowGraph.hpp.

◆ Traits

typedef boost::adjacency_list_traits< boost::vecS, boost::vecS, boost::directedS > pgrouting::Traits

Definition at line 39 of file pgr_costFlowGraph.hpp.

◆ UndirectedGraph

typedef graph::Pgr_base_graph<boost::adjacency_list < boost::vecS, boost::vecS, boost::undirectedS, Basic_vertex, Basic_edge >, Basic_vertex, Basic_edge > pgrouting::UndirectedGraph

Definition at line 186 of file pgr_base_graph.hpp.

◆ Weight

typedef boost::property_map< CostFlowGraph, boost::edge_weight_t >::type pgrouting::Weight

Definition at line 55 of file pgr_costFlowGraph.hpp.

◆ xyDirectedGraph

typedef graph::Pgr_base_graph<boost::adjacency_list < boost::listS, boost::vecS, boost::bidirectionalS, XY_vertex, Basic_edge >, XY_vertex, Basic_edge > pgrouting::xyDirectedGraph

Definition at line 204 of file pgr_base_graph.hpp.

◆ xyUndirectedGraph

typedef graph::Pgr_base_graph<boost::adjacency_list < boost::listS, boost::vecS, boost::undirectedS, XY_vertex, Basic_edge >, XY_vertex, Basic_edge > pgrouting::xyUndirectedGraph

Definition at line 198 of file pgr_base_graph.hpp.

Function Documentation

◆ check_vertices() [1/3]

size_t pgrouting::check_vertices ( std::vector< Basic_vertex > vertices )

Definition at line 42 of file basic_vertex.cpp.

                                                  {
         auto count(vertices.size());
         std::stable_sort(
                 vertices.begin(), vertices.end(),
                 [](const Basic_vertex &lhs, const Basic_vertex &rhs)
                 {return lhs.id < rhs.id;});
         vertices.erase(
                 std::unique(
                     vertices.begin(), vertices.end(),
                     [](const Basic_vertex &lhs, const Basic_vertex &rhs)
                     {return lhs.id == rhs.id;}), vertices.end());
  
         return vertices.size() - count;
     }

Referenced by pgrouting::graph::Pgr_base_graph< BG, XY_vertex, Basic_edge >::insert_edges(), and pgrouting::graph::Pgr_base_graph< BG, XY_vertex, Basic_edge >::Pgr_base_graph().

◆ check_vertices() [2/3]

size_t pgrouting::check_vertices ( std::vector< CH_vertex > vertices )

◆ check_vertices() [3/3]

size_t pgrouting::check_vertices ( std::vector< XY_vertex > vertices )

Definition at line 65 of file xy_vertex.cpp.

                                       {
     auto count(vertices.size());
     std::stable_sort(
         vertices.begin(), vertices.end(),
         [](const XY_vertex &lhs, const XY_vertex &rhs)
         {return lhs.id < rhs.id;});
     vertices.erase(
         std::unique(
             vertices.begin(), vertices.end(),
             [](const XY_vertex &lhs, const XY_vertex &rhs)
             {return lhs.id == rhs.id;}), vertices.end());
  
     return count - vertices.size();
 }

◆ extract_vertices() [1/7]

std::vector< Basic_vertex > pgrouting::extract_vertices	(	const pgr_edge_t *	data_edges,
		size_t	count
	)

Definition at line 124 of file basic_vertex.cpp.

                                                         {
         return extract_vertices(
                 std::vector < pgr_edge_t >(
                     data_edges, data_edges + count));
     }

References extract_vertices().

◆ extract_vertices() [2/7]

std::vector< XY_vertex > pgrouting::extract_vertices	(	const Pgr_edge_xy_t *	data_edges,
		size_t	count
	)

Definition at line 114 of file xy_vertex.cpp.

                                                    {
     return extract_vertices(
         std::vector < Pgr_edge_xy_t >(data_edges, data_edges + count));
 }

References extract_vertices().

◆ extract_vertices() [3/7]

std::vector< Basic_vertex > pgrouting::extract_vertices	(	const std::vector< Basic_vertex > &	vertices,
		const pgr_edge_t *	data_edges,
		size_t	count
	)

Definition at line 131 of file basic_vertex.cpp.

                                                         {
         return extract_vertices(
                 vertices, std::vector < pgr_edge_t >(
                     data_edges, data_edges + count));
     }

References extract_vertices().

◆ extract_vertices() [4/7]

std::vector< Basic_vertex > pgrouting::extract_vertices ( const std::vector< pgr_edge_t > & data_edges )

Definition at line 92 of file basic_vertex.cpp.

                                                        {
         std::vector< Basic_vertex > vertices;
         if (data_edges.empty()) return vertices;
  
         vertices.reserve(data_edges.size() * 2);
  
         for (const auto edge : data_edges) {
             Basic_vertex vertex;
  
             vertex.id = edge.source;
             vertices.push_back(vertex);
  
             vertex.id = edge.target;
             vertices.push_back(vertex);
         }
  
         /*
          * sort and delete duplicates
          */
         std::stable_sort(vertices.begin(), vertices.end(),
                 [](const Basic_vertex &lhs, const Basic_vertex &rhs)
                 {return lhs.id < rhs.id;});
  
         vertices.erase(
                 std::unique(vertices.begin(), vertices.end(),
                     [](const Basic_vertex &lhs, const Basic_vertex &rhs)
                     {return lhs.id == rhs.id;}), vertices.end());
  
         return vertices;
     }

References pgrouting::Basic_vertex::id, edge::source, and edge::target.

◆ extract_vertices() [5/7]

std::vector< XY_vertex > pgrouting::extract_vertices ( const std::vector< Pgr_edge_xy_t > & data_edges )

Definition at line 82 of file xy_vertex.cpp.

                                                   {
  
     std::vector< XY_vertex > vertices;
     if (data_edges.empty()) return vertices;
  
     vertices.reserve(data_edges.size() * 2);
  
     for (const auto &edge : data_edges) {
         XY_vertex v_source(edge, true);
         vertices.push_back(v_source);
  
         XY_vertex v_target(edge, false);
         vertices.push_back(v_target);
     }
  
     /*
      * sort and delete duplicates
      */
     std::stable_sort(
         vertices.begin(), vertices.end(),
         [](const XY_vertex &lhs, const XY_vertex &rhs)
         {return lhs.id < rhs.id;});
     vertices.erase(
         std::unique(
             vertices.begin(), vertices.end(),
             [](const XY_vertex &lhs, const XY_vertex &rhs)
             {return lhs.id == rhs.id;}), vertices.end());
     return vertices;
 }

◆ extract_vertices() [6/7]

std::vector< Basic_vertex > pgrouting::extract_vertices	(	std::vector< Basic_vertex >	vertices,
		const pgr_edge_t *	data_edges,
		size_t	count
	)

◆ extract_vertices() [7/7]

std::vector< Basic_vertex > pgrouting::extract_vertices	(	std::vector< Basic_vertex >	vertices,
		const std::vector< pgr_edge_t >	data_edges
	)

Definition at line 59 of file basic_vertex.cpp.

                                                       {
         if (data_edges.empty()) return vertices;
  
         vertices.reserve(vertices.size() + data_edges.size() * 2);
  
         for (const auto edge : data_edges) {
             Basic_vertex vertex;
  
             vertex.id = edge.source;
             vertices.push_back(vertex);
  
             vertex.id = edge.target;
             vertices.push_back(vertex);
         }
  
         /*
          * sort and delete duplicates
          */
         std::stable_sort(vertices.begin(), vertices.end(),
                 [](const Basic_vertex &lhs, const Basic_vertex &rhs)
                 {return lhs.id < rhs.id;});
  
         vertices.erase(
                 std::unique(vertices.begin(), vertices.end(),
                     [](const Basic_vertex &lhs, const Basic_vertex &rhs)
                     {return lhs.id == rhs.id;}), vertices.end());
  
         return vertices;
     }

References pgrouting::Basic_vertex::id, edge::source, and edge::target.

Referenced by do_pgr_astarManyToMany(), do_pgr_bdAstar(), do_pgr_driving_many_to_dist(), do_pgr_withPoints(), do_pgr_withPointsKsp(), extract_vertices(), and pgrouting::graph::Pgr_base_graph< BG, XY_vertex, Basic_edge >::insert_edges().

◆ operator<<() [1/6]

std::ostream& pgrouting::operator<<	(	std::ostream &	log,
		const Basic_vertex &	v
	)

Definition at line 37 of file basic_vertex.cpp.

                                                                    {
         log << v.id;
         return log;
     }

References pgrouting::Basic_vertex::id.

◆ operator<<() [2/6]

std::ostream& pgrouting::operator<<	(	std::ostream &	log,
		const Identifier &	ident
	)

Definition at line 51 of file identifier.cpp.

                                                                  {
     log << "id(idx) = " << ident.id() << "(" << ident.idx() << ")";
     return log;
 }

References pgrouting::Identifier::id(), and pgrouting::Identifier::idx().

◆ operator<<() [3/6]

std::ostream& pgrouting::operator<<	(	std::ostream &	log,
		const XY_vertex &	v
	)

Definition at line 51 of file xy_vertex.cpp.

                                                             {
     log << v.id << "-" << bg::wkt(v.point);
     return log;
 }

References pgrouting::XY_vertex::id, and pgrouting::XY_vertex::point.

◆ operator<<() [4/6]

std::ostream& pgrouting::operator<<	(	std::ostream &	os,
		const CH_edge &	e
	)

Definition at line 72 of file ch_edge.cpp.

                                                           {
     os << "{id: " << e.id << ",\t"
         << "source: " << e.source << ",\t"
         << "target: " << e.target << ",\t"
         << "cost: " << e.cost << ",\t"
         << "contracted vertices: "
         << e.contracted_vertices()
         << "}";
     return os;
 }

References pgrouting::CH_edge::contracted_vertices(), pgrouting::CH_edge::cost, pgrouting::CH_edge::id, pgrouting::CH_edge::source, and pgrouting::CH_edge::target.

◆ operator<<() [5/6]

std::ostream& pgrouting::operator<<	(	std::ostream &	os,
		const CH_vertex &	v
	)

Definition at line 60 of file ch_vertex.cpp.

                                                             {
     os << "{id: " << v.id << ",\t"
      << "contracted vertices: "
      << v.contracted_vertices()
      << "}";
     return os;
 }

References pgrouting::CH_vertex::contracted_vertices(), and pgrouting::CH_vertex::id.

◆ operator<<() [6/6]

std::ostream& pgrouting::operator<<	(	std::ostream &	os,
		const Pg_points_graph &	g
	)

Definition at line 46 of file pgr_withPoints.cpp.

                                                   {
     for (const auto p : g.m_points) {
         os << p.pid << "\t"
             << p.edge_id << "\t"
             << p.fraction << "\t"
             << p.side << "\n";
     }
     return os;
 }

References pgrouting::Pg_points_graph::m_points.

◆ pgr_dijkstra()

template<class G >

Path pgrouting::pgr_dijkstra	(	G &	graph,
		int64_t	source,
		int64_t	target,
		bool	only_cost = `false`
	)

Definition at line 87 of file pgr_dijkstra.hpp.

                                 {
     Pgr_dijkstra< G > fn_dijkstra;
     return fn_dijkstra.dijkstra(graph, source, target, only_cost);
 }

References pgrouting::Pgr_dijkstra< G >::dijkstra().

◆ pgr_drivingDistance()

template<class G >

std::deque<Path> pgrouting::pgr_drivingDistance	(	G &	graph,
		std::vector< int64_t >	start_vids,
		double	distance,
		bool	equicost,
		std::ostringstream &	log
	)

Definition at line 68 of file pgr_dijkstra.hpp.

                                {
     Pgr_dijkstra< G > fn_dijkstra;
     return fn_dijkstra.drivingDistance(
             graph,
             start_vids,
             distance,
             equicost,
             log);
 }

References pgrouting::Pgr_dijkstra< G >::drivingDistance().

Referenced by do_pgr_driving_many_to_dist(), and do_pgr_many_withPointsDD().

Namespaces

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ BasicDirectedGraph

◆ BasicUndirectedGraph

◆ Bline

◆ Blines

◆ Bpoint

◆ Bpoints

◆ Bpoly

◆ Bpolys

◆ Capacity

◆ CostFlowGraph

◆ DirectedGraph

◆ FlowGraph

◆ LinearDirectedGraph

◆ ResidualCapacity

◆ Reversed

◆ Traits

◆ UndirectedGraph

◆ Weight

◆ xyDirectedGraph

◆ xyUndirectedGraph

Function Documentation

◆ check_vertices() [1/3]

◆ check_vertices() [2/3]

◆ check_vertices() [3/3]

◆ extract_vertices() [1/7]

◆ extract_vertices() [2/7]

◆ extract_vertices() [3/7]

◆ extract_vertices() [4/7]

◆ extract_vertices() [5/7]

◆ extract_vertices() [6/7]

◆ extract_vertices() [7/7]

◆ operator<<() [1/6]

◆ operator<<() [2/6]

◆ operator<<() [3/6]

◆ operator<<() [4/6]

◆ operator<<() [5/6]

◆ operator<<() [6/6]

◆ pgr_dijkstra()

◆ pgr_drivingDistance()