void rOctree<T>::QueryNodesWithBox(const box_type& b , node_list& result) {
result.clear();
if (! m_root || ! m_root->m_volume.IntersectsBox(b))
return;
result.push_back(m_root);
QueryNodesWithBoxRec(b , result , m_root);
}
node parent( node_list& v, node n )
{
if( n >= v.size( ) ) {
for( unsigned i = v.size( ); i <= n; i++ ) {
v.push_back( i );
}
}
if( v[ n ] == n ) return n;
v[ n ] = parent( v, v[ n ] );
return v[ n ];
}
void rOctree<T>::QueryNodesWithBoxRec(const box_type& b , node_list& result, node_type* node) {
for (size_t i =0; i < node->m_children.size(); i++) {
if (node->m_children[i] && node->m_children[i]->m_volume.IntersectsBox(b)) {
result.push_back(node->m_children[i]);
QueryNodesWithBoxRec(b , result, node->m_children[i]);
}
}
}
void generate_generation_table(node_list& nlist, combo::type_tree& ttree, generation_table& gtable) {
std::vector<combo::type_tree> type_node_list;
std::vector<node_list> type_lists;
combo::type_tree_seq atlist = combo::get_signature_inputs(ttree);
for (std::set<combo::vertex>::iterator it = nlist.begin(); it != nlist.end(); ++it) {
generation_node gnode;
combo::type_tree outttree = combo::get_output_type_tree(*it);
gnode.node = outttree;
if (!type_registered(outttree, gtable))
gtable.push_back(gnode);
int temp;
for (temp = 0; (temp != (int)type_node_list.size()) and (!combo::equal_type_tree(type_node_list[temp], outttree)); temp++);
if (temp == (int)type_node_list.size()) {
type_node_list.push_back(outttree);
node_list tempnlist;
tempnlist.insert(*it);
type_lists.push_back(tempnlist);
} else {
type_lists[temp].insert(*it);
}
}
for (int i = 0; i < (int)atlist.size(); i++) {
combo::argument arg(i + 1);
int temp;
for (temp = 0; (temp != (int)type_node_list.size()) and (!combo::equal_type_tree(atlist[i], type_node_list[temp])); temp++);
if (temp == (int)type_node_list.size()) {
printf("Error. No candidates possible for given signature");
exit(1);
} else {
type_lists[temp].insert(arg);
}
}
for (std::vector<generation_node>::iterator it = gtable.begin(); it != gtable.end(); ++it) {
for (int it2 = 0; it2 != (int)type_node_list.size(); it2++) {
if (combo::equal_type_tree(type_node_list[it2], it->node))
it->glist = type_lists[it2];
}
}
}
void landmark_selection(const graph &G,const edge_array<double>& cost,
node_list &landmarks) {
node_pq<double> PQ(G);
node v,s; edge e;
node_array<double> dist(G);
node_array<edge> na(G);
node u;
s = G.choose_node(); //Start from s for choosing landmarks
for(int landmarkSelected = 0; landmarkSelected < LANDMARKCOUNT; landmarkSelected++ ) {
#pragma omp section
{
forall_nodes(v,G) {
if(v == s) dist[v] = 0; else dist[v] = MAXDOUBLE;
PQ.insert(v,dist[v]);
} }
while ( !PQ.empty() ) {
u = PQ.del_min();
if( dist[u] == MAXDOUBLE ) {
PQ.clear();
break;
}
forall_adj_edges(e,u) {
v = target(e);
double c = dist[u] + cost[e];
if ( c < dist[v] ) {
PQ.decrease_p(v,c); dist[v] = c;
}
}
}
landmarks.append( u ); //Select the farthest node from s as landmark
s = u; //Next Source for another landmark selection
} //Landmark Selection loop
void Dijkstra(int start, const node_list &node_list,
vector<float> &min_distance,
vector<int> &previous)
{
int n = node_list.size();
min_distance.clear();
min_distance.resize(n, max_distance);
min_distance[start] = 0;
previous.clear();
previous.resize(n, -1);
set< pair<float, int> > vertex_queue;
vertex_queue.insert(make_pair(min_distance[start], start));
while (!vertex_queue.empty())
{
float dist = vertex_queue.begin()->first;
int u = vertex_queue.begin()->second;
vertex_queue.erase(vertex_queue.begin());
const vector<neighbor> &neighbors = node_list[u];
for (vector<neighbor>::const_iterator it
= neighbors.begin();
it != neighbors.end();
it++)
{
int v = it->next;
float distance = it->distance;
float distance_through_u = dist + distance;
if (distance_through_u < min_distance[v])
{
vertex_queue.erase(make_pair(min_distance[v], v));
min_distance[v] = distance_through_u;
previous[v] = u;
vertex_queue.insert(make_pair(min_distance[v], v));
}
}
}
}
