kazu
9947dced15
added new helper methods/classes (e.g. for heading) new test cases optimize the dijkstra cleanups/refactoring added timed-benchmarks to the log many more...
138 lines
3.7 KiB
C++
138 lines
3.7 KiB
C++
#ifndef DIJKSTRA_H
|
|
#define DIJKSTRA_H
|
|
|
|
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <unordered_set>
|
|
#include <list>
|
|
|
|
#include "DijkstraStructs.h"
|
|
#include "../../misc/Debug.h"
|
|
#include "../../misc/Time.h"
|
|
|
|
#include <KLib/Assertions.h>
|
|
|
|
template <typename T> class Dijkstra {
|
|
|
|
/** all allocated nodes for the user-data inputs */
|
|
std::unordered_map<const T*, DijkstraNode<T>*> nodes;
|
|
|
|
/** all already processed edges */
|
|
std::unordered_set<DijkstraEdge<T>> usedEdges;
|
|
|
|
/** to-be-processed nodes (NOTE: using std::list here was SLOWER!) */
|
|
std::vector<DijkstraNode<T>*> toBeProcessedNodes;
|
|
|
|
public:
|
|
|
|
/** get the dijkstra-pendant for the given user-node */
|
|
DijkstraNode<T>* getNode(const T& userNode) {
|
|
return nodes[&userNode];
|
|
}
|
|
|
|
/** build shortest path from start to end using the provided wrapper-class */
|
|
template <typename Access> void build(const T& start, const T& end, const Access& acc) {
|
|
|
|
// NOTE: end is currently ignored!
|
|
// runs until all nodes were evaluated
|
|
|
|
// compare two nodes by their distance from the start
|
|
static auto comp = [] (const DijkstraNode<T>* n1, const DijkstraNode<T>* n2) {return n1->cumWeight < n2->cumWeight;};
|
|
|
|
Log::add("Dijkstra", "calculating dijkstra from " + (std::string)start + " to ALL OTHER nodes");
|
|
|
|
// cleanup
|
|
toBeProcessedNodes.clear();
|
|
usedEdges.clear();
|
|
nodes.clear();
|
|
|
|
// run from start
|
|
const T* cur = &start;
|
|
|
|
// create a node for the start element
|
|
DijkstraNode<T>* dnStart = getNode(cur);
|
|
dnStart->cumWeight = 0;
|
|
|
|
// add this node to the processing list
|
|
toBeProcessedNodes.push_back(dnStart);
|
|
|
|
// until we are done
|
|
while(!toBeProcessedNodes.empty()) {
|
|
|
|
// get the next to-be-processed node
|
|
const auto min = std::min_element(toBeProcessedNodes.begin(), toBeProcessedNodes.end(), comp);
|
|
DijkstraNode<T>* dnSrc = *min;
|
|
|
|
// stop when end was reached??
|
|
//if (dnSrc->element == &end) {break;}
|
|
|
|
// and remove him from the list
|
|
toBeProcessedNodes.erase(min);
|
|
|
|
// process each neighbor of the current element
|
|
for (int i = 0; i < acc.getNumNeighbors(*dnSrc->element); ++i) {
|
|
|
|
// get the neighbor itself
|
|
const T* dst = acc.getNeighbor(*dnSrc->element, i);
|
|
|
|
// get the distance-weight to the neighbor
|
|
const float weight = acc.getWeightBetween(*dnSrc->element, *dst);
|
|
_assertTrue(weight >= 0, "edge-weight must not be negative!");
|
|
|
|
// get-or-create a node for the neighbor
|
|
DijkstraNode<T>* dnDst = getNode(dst);
|
|
|
|
// get-or-create the edge describing the connection
|
|
const DijkstraEdge<T> edge = getEdge(dnSrc, dnDst);
|
|
|
|
// was this edge already processed? -> skip it
|
|
if (usedEdges.find(edge) != usedEdges.end()) {continue;}
|
|
|
|
// otherwise: remember it
|
|
usedEdges.insert(edge);
|
|
|
|
|
|
|
|
// and add the node for later processing
|
|
toBeProcessedNodes.push_back(dnDst);
|
|
|
|
// update the weight to the destination?
|
|
const float potentialWeight = dnSrc->cumWeight + weight;
|
|
if (potentialWeight < dnDst->cumWeight) {
|
|
dnDst->cumWeight = potentialWeight;
|
|
dnDst->previous = dnSrc;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// reclaim temporal memory
|
|
toBeProcessedNodes.clear();
|
|
usedEdges.clear();
|
|
|
|
Log::add("Dijkstra", "processed " + std::to_string(nodes.size()) + " nodes");
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
/** get (or create) a new node for the given user-node */
|
|
inline DijkstraNode<T>* getNode(const T* userNode) {
|
|
if (nodes.find(userNode) == nodes.end()) {
|
|
DijkstraNode<T>* dn = new DijkstraNode<T>(userNode);
|
|
nodes[userNode] = dn;
|
|
}
|
|
return nodes[userNode];
|
|
}
|
|
|
|
/** get the edge (bi-directional) between the two given nodes */
|
|
inline DijkstraEdge<T> getEdge(const DijkstraNode<T>* n1, const DijkstraNode<T>* n2) const {
|
|
return DijkstraEdge<T>(n1, n2);
|
|
}
|
|
|
|
};
|
|
|
|
#endif // DIJKSTRA_H
|