void
do_pgr_one_to_one_dijkstra(
pgr_edge_t *data_edges,
size_t total_tuples,
int64_t start_vid,
int64_t end_vid,
bool directed,
bool only_cost,
General_path_element_t **return_tuples,
size_t *return_count,
char ** err_msg) {
std::ostringstream log;
try {
graphType gType = directed? DIRECTED: UNDIRECTED;
Path path;
if (directed) {
log << "Working with directed Graph\n";
pgrouting::DirectedGraph digraph(gType);
digraph.graph_insert_data(data_edges, total_tuples);
pgr_dijkstra(digraph, path, start_vid, end_vid, only_cost);
} else {
log << "Working with Undirected Graph\n";
pgrouting::UndirectedGraph undigraph(gType);
undigraph.graph_insert_data(data_edges, total_tuples);
pgr_dijkstra(undigraph, path, start_vid, end_vid, only_cost);
}
size_t count(0);
count = path.size();
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;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
size_t sequence = 0;
path.generate_postgres_data(return_tuples, sequence);
(*return_count) = sequence;
#ifndef DEBUG
*err_msg = strdup("OK");
#else
*err_msg = strdup(log.str().c_str());
#endif
return;
} catch ( ... ) {
log << "Caught unknown exception!\n";
*err_msg = strdup(log.str().c_str());
return;
}
}
char *
pgr_msg(const std::string &msg) {
char* duplicate = NULL;
duplicate = pgr_alloc(msg.size() + 1, duplicate);
memcpy(duplicate, msg.c_str(), msg.size());
duplicate[msg.size()] = '\0';
return duplicate;
}
void
do_pgr_MY_FUNCTION_NAME(
MY_EDGE_TYPE *data_edges,
size_t total_edges,
int64_t start_vid,
int64_t end_vid,
bool directed,
bool only_cost,
MY_RETURN_VALUE_TYPE **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);
graphType gType = directed? DIRECTED: UNDIRECTED;
Path path;
if (directed) {
log << "Working with directed Graph\n";
pgrouting::DirectedGraph digraph(gType);
digraph.insert_edges(data_edges, total_edges);
path = pgr_MY_FUNCTION_NAME(digraph,
start_vid,
end_vid,
only_cost);
} else {
log << "Working with Undirected Graph\n";
pgrouting::UndirectedGraph undigraph(gType);
undigraph.insert_edges(data_edges, total_edges);
path = pgr_MY_FUNCTION_NAME(
undigraph,
start_vid,
end_vid,
only_cost);
}
auto count = path.size();
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
notice <<
"No paths found between start_vid and end_vid vertices";
return;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
size_t sequence = 0;
path.generate_postgres_data(return_tuples, sequence);
(*return_count) = sequence;
pgassert(*err_msg == NULL);
*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_maximum_cardinality_matching(
pgr_basic_edge_t *data_edges,
size_t total_tuples,
bool directed,
pgr_basic_edge_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 {
std::vector<pgr_basic_edge_t> matched_vertices;
if (directed) {
pgrouting::flow::PgrCardinalityGraph<
pgrouting::BasicDirectedGraph> G;
G.create_max_cardinality_graph(data_edges, total_tuples);
std::vector<int64_t> mate_map(boost::num_vertices(G.boost_graph));
G.maximum_cardinality_matching(mate_map);
G.get_matched_vertices(matched_vertices, mate_map);
} else {
pgrouting::flow::PgrCardinalityGraph<
pgrouting::BasicUndirectedGraph> G;
G.create_max_cardinality_graph(data_edges, total_tuples);
std::vector<int64_t> mate_map(boost::num_vertices(G.boost_graph));
G.maximum_cardinality_matching(mate_map);
G.get_matched_vertices(matched_vertices, mate_map);
}
(*return_tuples) = pgr_alloc(matched_vertices.size(), (*return_tuples));
for (size_t i = 0; i < matched_vertices.size(); ++i) {
(*return_tuples)[i] = matched_vertices[i];
}
*return_count = matched_vertices.size();
*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_max_flow(
pgr_edge_t *data_edges,
size_t total_tuples,
int64_t *source_vertices,
size_t size_source_verticesArr,
int64_t *sink_vertices,
size_t size_sink_verticesArr,
char *algorithm,
bool only_flow,
pgr_flow_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(data_edges);
pgassert(source_vertices);
pgassert(sink_vertices);
pgrouting::graph::PgrFlowGraph<pgrouting::FlowGraph> G;
std::set<int64_t> set_source_vertices;
std::set<int64_t> set_sink_vertices;
for (size_t i = 0; i < size_source_verticesArr; ++i) {
set_source_vertices.insert(source_vertices[i]);
}
for (size_t i = 0; i < size_sink_verticesArr; ++i) {
set_sink_vertices.insert(sink_vertices[i]);
}
std::set<int64_t> vertices(set_source_vertices);
vertices.insert(set_sink_vertices.begin(), set_sink_vertices.end());
if (vertices.size()
!= (set_source_vertices.size() + set_sink_vertices.size())) {
*err_msg = pgr_msg("A source found as sink");
// TODO(vicky) return as hint the sources that are also sinks
return;
}
G.create_flow_graph(data_edges, total_tuples, set_source_vertices,
set_sink_vertices, algorithm);
int64_t max_flow;
if (strcmp(algorithm, "push_relabel") == 0) {
max_flow = G.push_relabel();
} else if (strcmp(algorithm, "edmonds_karp") == 0) {
max_flow = G.edmonds_karp();
} else if (strcmp(algorithm, "boykov_kolmogorov") == 0) {
max_flow = G.boykov_kolmogorov();
} else {
log << "Unspecified algorithm!\n";
*err_msg = pgr_msg(log.str().c_str());
(*return_tuples) = NULL;
(*return_count) = 0;
return;
}
std::vector<pgr_flow_t> flow_edges;
if (only_flow) {
pgr_flow_t edge;
edge.edge = -1;
edge.source = -1;
edge.target = -1;
edge.flow = max_flow;
edge.residual_capacity = -1;
flow_edges.push_back(edge);
} else {
G.get_flow_edges(flow_edges);
}
(*return_tuples) = pgr_alloc(flow_edges.size(), (*return_tuples));
for (size_t i = 0; i < flow_edges.size(); ++i) {
(*return_tuples)[i] = flow_edges[i];
}
*return_count = flow_edges.size();
*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_connectedComponents(
pgr_edge_t *data_edges,
size_t total_edges,
pgr_components_rt **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);
graphType gType = UNDIRECTED;
std::vector<pgr_components_rt> results;
log << "Working with Undirected Graph\n";
pgrouting::ComponentsUndiGraph undigraph(gType);
undigraph.insert_edges(data_edges, total_edges);
results = pgr_connectedComponents(
undigraph);
auto count = results.size();
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
notice <<
"No paths found between start_vid and end_vid vertices";
return;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
for (size_t i = 0; i < count; i++) {
*((*return_tuples) + i) = results[i];
}
(*return_count) = count;
pgassert(*err_msg == NULL);
*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_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());
}
}
// 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());
}
}
void
do_pgr_tsp(
Matrix_cell_t *distances,
size_t total_distances,
int64_t start_vid,
int64_t end_vid,
double initial_temperature,
double final_temperature,
double cooling_factor,
int64_t tries_per_temperature,
int64_t max_changes_per_temperature,
int64_t max_consecutive_non_changes,
bool randomize,
double time_limit,
General_path_element_t **return_tuples,
size_t *return_count,
char **log_msg,
char **err_msg) {
std::ostringstream err;
std::ostringstream log;
try {
std::vector < Matrix_cell_t > data_costs(
distances,
distances + total_distances);
pgrouting::tsp::Dmatrix costs(data_costs);
if (!costs.has_no_infinity()) {
err << "An Infinity value was found on the Matrix";
*err_msg = strdup(err.str().c_str());
*log_msg = strdup(log.str().c_str());
return;
}
if (!costs.is_symmetric()) {
err << "A Non symmetric Matrix was given as input";
*err_msg = strdup(err.str().c_str());
*log_msg = strdup(log.str().c_str());
return;
}
double real_cost = -1;
size_t idx_start = costs.has_id(start_vid) ?
costs.get_index(start_vid) : 0;
size_t idx_end = costs.has_id(end_vid) ?
costs.get_index(end_vid) : 0;
if (costs.has_id(start_vid) && costs.has_id(end_vid) && start_vid != end_vid) {
/* An ending vertex needs to be by the starting vertex */
real_cost = costs.distance(idx_start, idx_end);
costs.set(idx_start, idx_end, 0);
}
log << "pgr_eucledianTSP Processing Information \nInitializing tsp class --->";
pgrouting::tsp::TSP<pgrouting::tsp::Dmatrix> tsp(costs);
log << " tsp.greedyInitial --->";
tsp.greedyInitial(idx_start);
log << " tsp.annealing --->";
tsp.annealing(
initial_temperature,
final_temperature,
cooling_factor,
tries_per_temperature,
max_changes_per_temperature,
max_consecutive_non_changes,
randomize,
time_limit);
log << " OK\n";
log << tsp.get_log();
log << tsp.get_stats();
auto bestTour(tsp.get_tour());
if (costs.has_id(start_vid) && costs.has_id(end_vid) && start_vid != end_vid) {
costs.set(idx_start, idx_end, real_cost);
}
log << "\nBest cost reached = " << costs.tourCost(bestTour);
auto start_ptr = std::find(
bestTour.cities.begin(),
bestTour.cities.end(),
idx_start);
std::rotate(
bestTour.cities.begin(),
start_ptr,
bestTour.cities.end());
if (costs.has_id(start_vid) && costs.has_id(end_vid) && start_vid != end_vid) {
if (*(bestTour.cities.begin() + 1) == idx_end) {
std::reverse(
bestTour.cities.begin() + 1,
bestTour.cities.end());
}
}
std::vector< General_path_element_t > result;
result.reserve(bestTour.cities.size() + 1);
pgassert(bestTour.cities.size() == costs.size());
bestTour.cities.push_back(bestTour.cities.front());
auto prev_id = bestTour.cities.front();
double agg_cost = 0;
for (const auto &id : bestTour.cities) {
if (id == prev_id) continue;
General_path_element_t data;
data.node = costs.get_id(prev_id);
data.edge = prev_id;
data.cost = costs.distance(prev_id, id);
data.agg_cost = agg_cost;
result.push_back(data);
agg_cost += data.cost;
prev_id = id;
}
/* inserting the returning to starting point */
{
General_path_element_t data;
data.node = costs.get_id(bestTour.cities.front());
data.edge = bestTour.cities.front();
data.cost = costs.distance(prev_id, bestTour.cities.front());
agg_cost += data.cost;
data.agg_cost = agg_cost;
result.push_back(data);
}
pgassert(result.size() == bestTour.cities.size());
*return_count = bestTour.size();
(*return_tuples) = pgr_alloc(result.size(), (*return_tuples));
/* store the results */
int seq = 0;
for (const auto &row : result) {
(*return_tuples)[seq] = row;
++seq;
}
*log_msg = strdup(log.str().c_str());
(*err_msg) = NULL;
return;
} catch (AssertFailedException &except) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
err << except.what() << "\n";
*err_msg = strdup(err.str().c_str());
*log_msg = strdup(log.str().c_str());
} catch (std::exception& except) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
err << except.what() << "\n";
*err_msg = strdup(err.str().c_str());
*log_msg = strdup(log.str().c_str());
} catch(...) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
err << "Caught unknown exception!\n";
*err_msg = strdup(err.str().c_str());
*log_msg = strdup(log.str().c_str());
}
}
/************************************************************
MY_QUERY_LINE1
***********************************************************/
void
do_pgr_MY_FUNCTION_NAME(
MY_EDGE_TYPE *data_edges, size_t total_edges,
int64_t start_vid,
int64_t *end_vidsArr, size_t size_end_vidsArr,
bool directed,
MY_RETURN_VALUE_TYPE **return_tuples,
size_t *return_count,
char ** log_msg,
char ** err_msg){
std::ostringstream err;
std::ostringstream log;
try {
pgassert(!(*log_msg));
pgassert(!(*err_msg));
pgassert(!(*return_tuples));
pgassert(*return_count == 0);
pgassert(total_edges != 0);
/* depending on the functionality some tests can be done here
* For example */
if (total_edges <= 1) {
err << "Required: more than one edges\n";
(*return_tuples) = NULL;
(*return_count) = 0;
*err_msg = strdup(err.str().c_str());
return;
}
graphType gType = directed? DIRECTED: UNDIRECTED;
std::deque< Path >paths;
// samll logs
log << "Inserting vertices into a c++ vector structure\n";
std::vector< int64_t > end_vertices(end_vidsArr, end_vidsArr + size_end_vidsArr);
std::sort(end_vertices.begin(),end_vertices.end());
#ifndef NDEBUG
// big logs with cycles wrap them so on release they wont consume time
log << "end vids: ";
for (const auto &vid : end_vertices) log << vid << ",";
log << "\nstart vid:" << start_vid << "\n";
#endif
if (directed) {
// very detailed logging
log << "Working with directed Graph\n";
pgRouting::DirectedGraph digraph(gType);
log << "Working with directed Graph 1 \n";
digraph.graph_insert_data(data_edges, total_edges);
#ifndef NDEBUG
// a graph log is a big log
log << digraph;
#endif
log << "Working with directed Graph 2\n";
pgr_dijkstra(digraph, paths, start_vid, end_vertices, false);
log << "Working with directed Graph 3\n";
} else {
// maybe the code is working so cleaner logging
log << "Working with Undirected Graph\n";
pgRouting::UndirectedGraph undigraph(gType);
undigraph.graph_insert_data(data_edges, total_edges);
pgr_dijkstra(undigraph, paths, start_vid, end_vertices, false);
}
// use auto when possible
auto 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;
}
// get the space required to store all the paths
(*return_tuples) = pgr_alloc(count, (*return_tuples));
log << "Converting a set of paths into the tuples\n";
(*return_count) = (collapse_paths(return_tuples, paths));
*err_msg = NULL;
*log_msg = strdup(log.str().c_str());
} catch (AssertFailedException &exept) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
err << exept.what() << "\n";
*err_msg = strdup(log.str().c_str());
*log_msg = strdup(log.str().c_str());
} catch (std::exception& exept) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
err << exept.what() << "\n";
*err_msg = strdup(log.str().c_str());
*log_msg = strdup(log.str().c_str());
} catch(...) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
err << "Caught unknown exception!\n";
*err_msg = strdup(log.str().c_str());
*log_msg = strdup(log.str().c_str());
}
}
int BiDirAStar:: bidir_astar(edge_astar_t *edges, size_t edge_count, int maxNode, int start_vertex, int end_vertex,
path_element_t **path, size_t *path_count, char **err_msg) {
max_node_id = maxNode;
max_edge_id = -1;
// Allocate memory for local storage like cost and parent holder
initall(maxNode);
// construct the graph from the edge list, i.e. populate node and edge data structures
construct_graph(edges, edge_count, maxNode);
m_lStartNodeId = start_vertex;
m_lEndNodeId = end_vertex;
// int nodeCount = m_vecNodeVector.size();
MinHeap fque(maxNode + 2);
MinHeap rque(maxNode + 2);
// std::priority_queue<PDI, std::vector<PDI>, std::greater<PDI> > fque;
// std::priority_queue<PDI, std::vector<PDI>, std::greater<PDI> > rque;
m_vecPath.clear();
// Initialize the forward search
m_pFParent[start_vertex].par_Node = -1;
m_pFParent[start_vertex].par_Edge = -1;
m_pFCost[start_vertex] = 0.0;
fque.push(std::make_pair(0.0, start_vertex));
// Initialize the reverse search
m_pRParent[end_vertex].par_Node = -1;
m_pRParent[end_vertex].par_Edge = -1;
m_pRCost[end_vertex] = 0.0;
rque.push(std::make_pair(0.0, end_vertex));
// int new_node;
int cur_node;
// int dir;
/*
The main loop. The algorithm is as follows:
1. IF the sum of the current minimum of both heap is greater than so far found path, we cannot get any better, so break the loop.
2. IF the reverse heap minimum is lower than the forward heap minimum, explore from reverse direction.
3. ELSE explore from the forward directtion.
*/
while (!fque.empty() && !rque.empty()) {
PDI fTop = fque.top();
PDI rTop = rque.top();
if (m_pFCost[fTop.second] + m_pRCost[rTop.second] > m_MinCost) // We are done, there is no path with lower cost
break;
if (rTop.first < fTop.first) {
// Explore from reverse queue
if (rTop.first > m_MinCost)
break;
cur_node = rTop.second;
int dir = -1;
rque.pop();
explore(cur_node, m_pRCost[rTop.second], dir, rque);
} else {
// Explore from forward queue
if (fTop.first > m_MinCost)
break;
cur_node = fTop.second;
int dir = 1;
fque.pop();
explore(cur_node, m_pFCost[fTop.second], dir, fque);
}
}
/*
Path reconstruction part. m_MidNode is the joining point where two searches meet to make a shortest path. It is updated in explore.
If it contains -1, then no path is found. Other wise we have a shortest path and that is reconstructed in the m_vecPath.
*/
if (m_MidNode == -1) {
*err_msg = (char *)"Path Not Found";
deleteall();
return -1;
} else {
// reconstruct path from forward search
fconstruct_path(m_MidNode);
// reconstruct path from backward search
rconstruct_path(m_MidNode);
// insert the last row in the path trace (having edge_id = -1 and cost = 0.0)
path_element_t pelement;
pelement.vertex_id = end_vertex;
pelement.edge_id = -1;
pelement.cost = 0.0;
m_vecPath.push_back(pelement);
// Transfer data path to path_element_t format and allocate memory and populate the pointer
*path = pgr_alloc(m_vecPath.size(), *path);
*path_count = m_vecPath.size();
for (size_t i = 0; i < *path_count; i++) {
(*path)[i].vertex_id = m_vecPath[i].vertex_id;
(*path)[i].edge_id = m_vecPath[i].edge_id;
(*path)[i].cost = m_vecPath[i].cost;
}
}
deleteall();
return 0;
}
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());
}
}
void
do_pgr_dijkstraVia(
pgr_edge_t* data_edges, size_t total_edges,
int64_t* via_vidsArr, size_t size_via_vidsArr,
bool directed,
bool strict,
bool U_turn_on_edge,
Routes_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;
std::deque< Path >paths;
log << "\nInserting vertices into a c++ vector structure";
std::vector< int64_t > via_vertices(
via_vidsArr, via_vidsArr + size_via_vidsArr);
if (directed) {
log << "\nWorking with directed Graph";
pgrouting::DirectedGraph digraph(gType);
digraph.insert_edges(data_edges, total_edges);
pgr_dijkstraViaVertex(
digraph,
via_vertices,
paths,
strict,
U_turn_on_edge,
log);
} else {
log << "\nWorking with Undirected Graph";
pgrouting::UndirectedGraph undigraph(gType);
undigraph.insert_edges(data_edges, total_edges);
pgr_dijkstraViaVertex(
undigraph,
via_vertices,
paths,
strict,
U_turn_on_edge,
log);
}
size_t 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;
}
// get the space required to store all the paths
(*return_tuples) = pgr_alloc(count, (*return_tuples));
log << "\nConverting a set of paths into the tuples";
(*return_count) = (get_route(return_tuples, paths));
(*return_tuples)[count - 1].edge = -2;
*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());
}
}
