void
do_pgr_driving_many_to_dist(
pgr_edge_t *data_edges, size_t total_tuples,
int64_t *start_vertex, size_t s_len,
float8 distance,
bool directedFlag,
bool equiCostFlag,
General_path_element_t **ret_path, size_t *path_count,
char ** err_msg) {
try {
graphType gType = directedFlag? DIRECTED: UNDIRECTED;
const auto initial_size = total_tuples;
std::deque< Path >paths;
std::set< int64_t > s_start_vertices(start_vertex, start_vertex + s_len);
std::vector< int64_t > start_vertices(s_start_vertices.begin(), s_start_vertices.end());
if (directedFlag) {
Pgr_base_graph< DirectedGraph > digraph(gType, initial_size);
digraph.graph_insert_data(data_edges, total_tuples);
pgr_drivingDistance(digraph, paths, start_vertices, distance, equiCostFlag);
} else {
Pgr_base_graph< UndirectedGraph > undigraph(gType, initial_size);
undigraph.graph_insert_data(data_edges, total_tuples);
pgr_drivingDistance(undigraph, paths, start_vertices, distance, equiCostFlag);
}
size_t count(count_tuples(paths));
if (count == 0) {
*err_msg = strdup("NOTICE: No return values was found");
*ret_path = noResult(path_count, (*ret_path));
return;
}
*ret_path = get_memory(count, (*ret_path));
auto trueCount(collapse_paths(ret_path, paths));
*path_count = trueCount;
#ifndef DEBUG
*err_msg = strdup("OK");
#else
*err_msg = strdup(log.str().c_str());
#endif
return;
} catch ( ... ) {
*err_msg = strdup("Caught unknown expection!");
*ret_path = noResult(path_count, (*ret_path));
return;
}
}
// CREATE OR REPLACE FUNCTION pgr_dijkstra(
// sql text,
// start_vids anyarray,
// end_vids anyarray,
// directed boolean default true,
void
do_pgr_many_to_many_dijkstra(
pgr_edge_t *data_edges,
size_t total_edges,
int64_t *start_vidsArr,
size_t size_start_vidsArr,
int64_t *end_vidsArr,
size_t size_end_vidsArr,
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 err;
std::ostringstream notice;
try {
pgassert(total_edges != 0);
pgassert(!(*log_msg));
pgassert(!(*notice_msg));
pgassert(!(*err_msg));
pgassert(!(*return_tuples));
pgassert(*return_count == 0);
graphType gType = directed? DIRECTED: UNDIRECTED;
log << "Inserting vertices into a c++ vector structure";
std::vector<int64_t>
start_vertices(start_vidsArr, start_vidsArr + size_start_vidsArr);
std::vector< int64_t >
end_vertices(end_vidsArr, end_vidsArr + size_end_vidsArr);
std::deque< Path >paths;
if (directed) {
log << "\nWorking with directed Graph";
pgrouting::DirectedGraph digraph(gType);
digraph.insert_edges(data_edges, total_edges);
paths = pgr_dijkstra(
digraph,
start_vertices, end_vertices,
only_cost, normal);
} else {
log << "\nWorking with Undirected Graph";
pgrouting::UndirectedGraph undigraph(gType);
undigraph.insert_edges(data_edges, total_edges);
paths = pgr_dijkstra(
undigraph,
start_vertices, end_vertices,
only_cost, normal);
}
size_t count(0);
count = count_tuples(paths);
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
notice <<
"No paths found";
*log_msg = pgr_msg(notice.str().c_str());
return;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
log << "\nConverting a set of paths into the tuples";
(*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());
}
}
void
do_pgr_bdAstar(
Pgr_edge_xy_t *edges,
size_t total_edges,
int64_t *start_vidsArr,
size_t size_start_vidsArr,
int64_t *end_vidsArr,
size_t size_end_vidsArr,
bool directed,
int heuristic,
double factor,
double epsilon,
bool only_cost,
General_path_element_t **return_tuples,
size_t *return_count,
char ** log_msg,
char ** notice_msg,
char ** err_msg) {
std::ostringstream log;
std::ostringstream err;
std::ostringstream notice;
try {
pgassert(!(*log_msg));
pgassert(!(*notice_msg));
pgassert(!(*err_msg));
pgassert(!(*return_tuples));
pgassert(*return_count == 0);
pgassert(total_edges != 0);
log << "Inserting vertices into a c++ vector structure";
std::vector<int64_t>
start_vertices(start_vidsArr, start_vidsArr + size_start_vidsArr);
std::vector< int64_t >
end_vertices(end_vidsArr, end_vidsArr + size_end_vidsArr);
graphType gType = directed? DIRECTED: UNDIRECTED;
std::deque<Path> paths;
log << "starting process\n";
if (directed) {
log << "Working with directed Graph\n";
pgrouting::xyDirectedGraph digraph(
pgrouting::extract_vertices(edges, total_edges),
gType);
digraph.insert_edges(edges, total_edges);
paths = pgr_bdAstar(digraph,
start_vertices,
end_vertices,
heuristic,
factor,
epsilon,
log,
only_cost);
} else {
log << "Working with Undirected Graph\n";
pgrouting::xyUndirectedGraph undigraph(
pgrouting::extract_vertices(edges, total_edges),
gType);
undigraph.insert_edges(edges, total_edges);
paths = pgr_bdAstar(
undigraph,
start_vertices,
end_vertices,
heuristic,
factor,
epsilon,
log,
only_cost);
}
size_t count(0);
count = count_tuples(paths);
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
notice <<
"No paths found";
*log_msg = pgr_msg(notice.str().c_str());
return;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
log << "\nConverting a set of paths into the tuples";
(*return_count) = (collapse_paths(return_tuples, paths));
#if 0
auto count = path.size();
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
notice <<
"No paths found between start_vid and end_vid vertices";
} else {
(*return_tuples) = pgr_alloc(count, (*return_tuples));
size_t sequence = 0;
path.generate_postgres_data(return_tuples, sequence);
(*return_count) = sequence;
}
#endif
pgassert(*err_msg == NULL);
*log_msg = log.str().empty()?
nullptr :
pgr_msg(log.str().c_str());
*notice_msg = notice.str().empty()?
nullptr :
pgr_msg(notice.str().c_str());
} catch (AssertFailedException &except) {
if (*return_tuples) 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) {
if (*return_tuples) 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(...) {
if (*return_tuples) 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());
}
}
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());
}
}
int do_pgr_driving_many_to_dist(pgr_edge_t *data_edges, int64_t total_tuples,
int64_t *start_vertex, int s_len,
float8 distance,
bool directedFlag,
bool equiCostFlag,
pgr_path_element3_t **ret_path, int *path_count,
char ** err_msg) {
try {
// in c code this should this must have been checked:
// 1) end_vertex is in the data_edges
#if 0 // set to 1 if needed
std::ostringstream log;
#endif
graphType gType = directedFlag? DIRECTED: UNDIRECTED;
const int initial_size = 1;
std::deque< Path >paths;
typedef boost::adjacency_list < boost::vecS, boost::vecS,
boost::undirectedS,
boost_vertex_t, boost_edge_t > UndirectedGraph;
typedef boost::adjacency_list < boost::vecS, boost::vecS,
boost::bidirectionalS,
boost_vertex_t, boost_edge_t > DirectedGraph;
Pgr_dijkstra < DirectedGraph > digraph(gType, initial_size);
Pgr_dijkstra < UndirectedGraph > undigraph(gType, initial_size);
std::vector< int64_t > start_vertices(start_vertex, start_vertex + s_len);
if (directedFlag) {
digraph.initialize_graph(data_edges, total_tuples);
digraph.dijkstra_dd(paths, start_vertices, distance);
} else {
undigraph.initialize_graph(data_edges, total_tuples);
undigraph.dijkstra_dd(paths, start_vertices, distance);
}
if (equiCostFlag == false) {
int count(count_tuples(paths));
if (count == 0) {
*err_msg = strdup("NOTICE: No return values was found");
*ret_path = noPathFound3(-1, path_count, (*ret_path));
return 0;
}
*ret_path = pgr_get_memory3(count, (*ret_path));
int trueCount(collapse_paths(ret_path, paths));
*path_count = trueCount;
// assert (count == trueCount);
} else {
Path path = equi_cost(paths);
size_t count(path.size());
if (count == 0) {
*err_msg = strdup("NOTICE: No return values was found");
*ret_path = noPathFound3(-1, path_count, (*ret_path));
return 0;
}
int trueCount = 0;
*ret_path = pgr_get_memory3(count, (*ret_path));
path.dpPrint(ret_path, trueCount);
*path_count = trueCount;
// assert (count == trueCount);
}
#if 1
*err_msg = strdup("OK");
#else
*err_msg = strdup(log.str().c_str());
#endif
return EXIT_SUCCESS;
} catch ( ... ) {
*err_msg = strdup("Caught unknown expection!");
return -1;
}
}