Pg_points_graph::Pg_points_graph(
std::vector<Point_on_edge_t> p_points,
std::vector<pgr_edge_t> p_edges_of_points,
bool p_normal,
char p_driving_side,
bool p_directed) :
m_points(p_points),
m_o_points(p_points),
m_edges_of_points(p_edges_of_points),
m_normal(p_normal),
m_driving_side(p_driving_side),
m_directed(p_directed) {
if (!p_normal) {
reverse_sides();
}
if (!m_directed) {
m_driving_side = 'b';
}
check_points();
create_new_edges();
log << "constructor";
}
void
do_pgr_one_to_many_withPoints(
pgr_edge_t *edges, size_t total_edges,
Point_on_edge_t *points_p, size_t total_points,
pgr_edge_t *edges_of_points, size_t total_edges_of_points,
int64_t start_vid,
int64_t *end_pidsArr, size_t size_end_pidsArr,
char driving_side,
bool details,
bool directed,
bool only_cost,
General_path_element_t **return_tuples, size_t *return_count,
char ** log_msg,
char ** err_msg) {
std::ostringstream log;
std::ostringstream err;
try {
pgassert(!(*return_tuples));
pgassert((*return_count) == 0);
pgassert(!(*log_msg));
pgassert(!(*err_msg));
/*
* DOCUMENT:
* - Points are treated as the same point when the pid is the same
* therefore when two points have the same pid, but different edge/fraction
* an error is generated.
*/
std::vector< Point_on_edge_t >
points(points_p, points_p + total_points);
int errcode = check_points(points, log);
if (errcode) {
*log_msg = strdup(log.str().c_str());
err << "Unexpected point(s) with same pid but different edge/fraction/side combination found.";
*err_msg = strdup(err.str().c_str());
return;
}
std::vector< pgr_edge_t >
edges_to_modify(edges_of_points, edges_of_points + total_edges_of_points);
std::vector< pgr_edge_t > new_edges;
log << "driving_side" << driving_side << "\n";
create_new_edges(
points,
edges_to_modify,
driving_side,
new_edges);
log << "Inserting points into a c++ vector structure\n";
/*
* Eliminating duplicates
* & ordering the points
*/
std::set< int64_t > s_end_vertices(end_pidsArr, end_pidsArr + size_end_pidsArr);
std::vector< int64_t > end_vertices(s_end_vertices.begin(), s_end_vertices.end());
log << "start_vid" << start_vid << "\n";
log << "end_vertices";
for (const auto &vid : end_vertices) {
log << vid << "\n";
}
graphType gType = directed? DIRECTED: UNDIRECTED;
std::deque< Path > paths;
if (directed) {
log << "Working with directed Graph\n";
pgrouting::DirectedGraph digraph(
pgrouting::extract_vertices(
pgrouting::extract_vertices(edges, total_edges),
new_edges),
gType);
digraph.graph_insert_data(edges, total_edges);
digraph.graph_insert_data(new_edges);
pgr_dijkstra(digraph, paths, start_vid, end_vertices, only_cost);
} else {
log << "Working with Undirected Graph\n";
auto vertices(pgrouting::extract_vertices(edges, total_edges));
vertices = pgrouting::extract_vertices(vertices, new_edges);
pgrouting::UndirectedGraph undigraph(vertices, gType);
vertices.clear();
undigraph.graph_insert_data(edges, total_edges);
undigraph.graph_insert_data(new_edges);
pgr_dijkstra(undigraph, paths, start_vid, end_vertices, only_cost);
}
if (!details) {
for (auto &path : paths) {
eliminate_details(path, edges_to_modify);
}
}
/*
* order paths based on the end_pid
*/
std::sort(paths.begin(), paths.end(), [](const Path &a, const Path &b) {
return a.end_id() < b.end_id();
});
size_t count(0);
count = count_tuples(paths);
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
log <<
"No paths found between Starting and any of the Ending vertices\n";
*log_msg = strdup(log.str().c_str());
return;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
log << "Converting a set of paths into the tuples\n";
(*return_count) = (collapse_paths(return_tuples, paths));
*log_msg = strdup(log.str().c_str());
pgassert(!(*err_msg));
return;
} catch (AssertFailedException &except) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
*log_msg = strdup(log.str().c_str());
err << except.what() << "\n";
*err_msg = strdup(err.str().c_str());
} catch (std::exception& except) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
*log_msg = strdup(log.str().c_str());
err << except.what() << "\n";
*err_msg = strdup(err.str().c_str());
} catch(...) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
*log_msg = strdup(log.str().c_str());
err << "Caught unknown exception!\n";
*err_msg = strdup(err.str().c_str());
}
}
int
do_pgr_many_to_one_withPoints(
pgr_edge_t *edges, size_t total_edges,
Point_on_edge_t *points_p, size_t total_points,
pgr_edge_t *edges_of_points, size_t total_edges_of_points,
int64_t *start_pidsArr, size_t size_start_pidsArr,
int64_t end_vid,
char driving_side,
bool details,
bool directed,
bool only_cost,
General_path_element_t **return_tuples, size_t *return_count,
char ** err_msg) {
std::ostringstream log;
try {
std::vector< Point_on_edge_t >
points(points_p, points_p + total_points);
int errcode = check_points(points, log);
if (errcode) {
/* Point(s) with same pid but different edge/fraction/side combination found */
*err_msg = strdup(log.str().c_str());
return errcode;
}
std::vector< pgr_edge_t >
edges_to_modify(edges_of_points, edges_of_points + total_edges_of_points);
std::vector< pgr_edge_t > new_edges;
create_new_edges(
points,
edges_to_modify,
driving_side,
new_edges);
std::set< int64_t > s_start_vertices(start_pidsArr, start_pidsArr + size_start_pidsArr);
std::vector< int64_t > start_vertices(s_start_vertices.begin(), s_start_vertices.end());
graphType gType = directed? DIRECTED: UNDIRECTED;
std::deque< Path > paths;
if (directed) {
log << "Working with directed Graph\n";
pgrouting::DirectedGraph digraph(gType);
digraph.graph_insert_data(edges, total_edges);
digraph.graph_insert_data(new_edges);
pgr_dijkstra(digraph, paths, start_vertices, end_vid, only_cost);
} else {
log << "Working with Undirected Graph\n";
pgrouting::UndirectedGraph undigraph(gType);
undigraph.graph_insert_data(edges, total_edges);
undigraph.graph_insert_data(new_edges);
pgr_dijkstra(undigraph, paths, start_vertices, end_vid, only_cost);
}
#if 0
for (auto &path : paths) {
adjust_pids(points, path);
}
#endif
if (!details) {
for (auto &path : paths) {
eliminate_details(path, edges_to_modify);
}
}
/*
* order paths based on the start_pid
*/
std::sort(paths.begin(), paths.end(), [](const Path &a, const Path &b) {
return a.start_id() < b.start_id();
});
size_t count(0);
count = count_tuples(paths);
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
log <<
"No paths found between Starting and any of the Ending vertices\n";
*err_msg = strdup(log.str().c_str());
return 0;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
log << "Converting a set of paths into the tuples\n";
(*return_count) = (collapse_paths(return_tuples, paths));
#ifndef NDEBUG
{
std::ostringstream log;
log << "OK";
*err_msg = strdup(log.str().c_str());
}
#else
*err_msg = strdup(log.str().c_str());
#endif
return 0;
} catch ( ... ) {
log << "Caught unknown exception!\n";
*err_msg = strdup(log.str().c_str());
return 1000;
}
return 0;
}
void
do_pgr_withPoints(
pgr_edge_t *edges, size_t total_edges,
Point_on_edge_t *points_p, size_t total_points,
pgr_edge_t *edges_of_points, size_t total_edges_of_points,
int64_t *start_pidsArr, size_t size_start_pidsArr,
int64_t *end_pidsArr, size_t size_end_pidsArr,
char driving_side,
bool details,
bool directed,
bool only_cost,
bool normal,
General_path_element_t **return_tuples, size_t *return_count,
char** log_msg,
char** notice_msg,
char** err_msg) {
std::ostringstream log;
std::ostringstream notice;
std::ostringstream err;
try {
pgassert(!(*log_msg));
pgassert(!(*notice_msg));
pgassert(!(*err_msg));
pgassert(!(*return_tuples));
pgassert((*return_count) == 0);
pgassert(edges || edges_of_points);
pgassert(points_p);
pgassert(start_pidsArr);
pgassert(end_pidsArr);
std::vector< Point_on_edge_t >
points(points_p, points_p + total_points);
if (!normal) {
for (auto &point : points) {
if (point.side == 'r') {
point.side = 'l';
} else if (point.side == 'l') {
point.side = 'r';
}
point.fraction = 1 - point.fraction;
}
if (driving_side == 'r') {
driving_side = 'l';
} else if (driving_side == 'l') {
driving_side = 'r';
}
}
int errcode = check_points(points, log);
if (errcode) {
*log_msg = strdup(log.str().c_str());
err << "Unexpected point(s) with same pid"
<< " but different edge/fraction/side combination found.";
*err_msg = pgr_msg(err.str().c_str());
return;
}
std::vector< pgr_edge_t >
edges_to_modify(
edges_of_points, edges_of_points + total_edges_of_points);
std::vector< pgr_edge_t > new_edges;
create_new_edges(
points,
edges_to_modify,
driving_side,
new_edges, log);
std::vector<int64_t>
start_vertices(start_pidsArr, start_pidsArr + size_start_pidsArr);
std::vector< int64_t >
end_vertices(end_pidsArr, end_pidsArr + size_end_pidsArr);
auto vertices(pgrouting::extract_vertices(edges, total_edges));
vertices = pgrouting::extract_vertices(vertices, new_edges);
graphType gType = directed? DIRECTED: UNDIRECTED;
std::deque< Path > paths;
if (directed) {
log << "Working with directed Graph\n";
pgrouting::DirectedGraph digraph(vertices, gType);
digraph.insert_edges(edges, total_edges);
digraph.insert_edges(new_edges);
paths = pgr_dijkstra(
digraph,
start_vertices, end_vertices,
only_cost, normal);
} else {
log << "Working with Undirected Graph\n";
pgrouting::UndirectedGraph undigraph(vertices, gType);
undigraph.insert_edges(edges, total_edges);
undigraph.insert_edges(new_edges);
paths = pgr_dijkstra(
undigraph,
start_vertices, end_vertices,
only_cost, normal);
}
if (!details) {
for (auto &path : paths) {
eliminate_details(path, edges_to_modify);
}
}
/*
* order paths based on the start_pid, end_pid
*/
std::sort(paths.begin(), paths.end(),
[](const Path &a, const Path &b)
-> bool {
if (b.start_id() != a.start_id()) {
return a.start_id() < b.start_id();
}
return a.end_id() < b.end_id();
});
size_t count(0);
count = count_tuples(paths);
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
#if 0
log <<
"No paths found";
*err_msg = pgr_msg(log.str().c_str());
#endif
return;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
log << "Converting a set of paths into the tuples\n";
(*return_count) = (collapse_paths(return_tuples, paths));
*log_msg = log.str().empty()?
*log_msg :
pgr_msg(log.str().c_str());
*notice_msg = notice.str().empty()?
*notice_msg :
pgr_msg(notice.str().c_str());
} catch (AssertFailedException &except) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << except.what();
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
} catch (std::exception &except) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << except.what();
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
} catch(...) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << "Caught unknown exception!";
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
}
}
