Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

refactor member names in ImportEdge

Browse Source
This commit is contained in:
Dennis Luxen 2014-05-29 18:46:20 +02:00
parent cc40eb709c
commit 0766c3c62d
5 changed files with 70 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
Algorithms/StronglyConnectedComponents.h
View File

@ -152,52 +152,48 @@ class TarjanSCC
DeallocatingVector<TarjanEdge> edge_list;
for (const NodeBasedEdge &input_edge : input_edges)
{
if (input_edge.source() == input_edge.target())
if (input_edge.source == input_edge.target)
{
continue;
}
TarjanEdge edge;
if (input_edge.isForward())
if (input_edge.forward)
{
edge.source = input_edge.source();
edge.target = input_edge.target();
edge.data.forward = input_edge.isForward();
edge.data.backward = input_edge.isBackward();
edge.source = input_edge.source;
edge.target = input_edge.target;
edge.data.forward = input_edge.forward;
edge.data.backward = input_edge.backward;
}
else
{
edge.source = input_edge.target();
edge.target = input_edge.source();
edge.data.backward = input_edge.isForward();
edge.data.forward = input_edge.isBackward();
edge.source = input_edge.target;
edge.target = input_edge.source;
edge.data.backward = input_edge.forward;
edge.data.forward = input_edge.backward;
}
edge.data.distance = (std::max)((int)input_edge.weight(), 1);
edge.data.distance = (std::max)((int)input_edge.weight, 1);
BOOST_ASSERT(edge.data.distance > 0);
edge.data.shortcut = false;
// edge.data.roundabout = input_edge.isRoundabout();
// edge.data.ignoreInGrid = input_edge.ignoreInGrid();
edge.data.name_id = input_edge.name();
edge.data.type = input_edge.type();
// edge.data.isAccessRestricted = input_edge.isAccessRestricted();
edge.data.name_id = input_edge.name;
edge.data.type = input_edge.type;
edge.data.reversedEdge = false;
edge_list.push_back(edge);
if (edge.data.backward)
{
std::swap(edge.source, edge.target);
edge.data.forward = input_edge.isBackward();
edge.data.backward = input_edge.isForward();
edge.data.forward = input_edge.backward;
edge.data.backward = input_edge.forward;
edge.data.reversedEdge = true;
edge_list.push_back(edge);
}
}
std::vector<NodeBasedEdge>().swap(input_edges);
input_edges.shrink_to_fit();
BOOST_ASSERT_MSG(0 == input_edges.size() && 0 == input_edges.capacity(),
"input edge vector not properly deallocated");
std::sort(edge_list.begin(), edge_list.end());
m_node_based_graph = std::make_shared<TarjanDynamicGraph>(number_of_nodes, edge_list);
}

36
DataStructures/ImportEdge.cpp
View File

@ -29,19 +29,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
bool NodeBasedEdge::operator<(const NodeBasedEdge &e) const
{
if (source() == e.source())
if (source == e.source)
{
if (target() == e.target())
if (target == e.target)
{
if (weight() == e.weight())
if (weight == e.weight)
{
return (isForward() && isBackward() && ((!e.isForward()) || (!e.isBackward())));
return (forward && backward && ((!e.forward) || (!e.backward)));
}
return (weight() < e.weight());
return (weight < e.weight);
}
return (target() < e.target());
return (target < e.target);
}
return (source() < e.source());
return (source < e.source);
}
NodeBasedEdge::NodeBasedEdge(NodeID s,
@ -56,8 +56,8 @@ bool NodeBasedEdge::operator<(const NodeBasedEdge &e) const
bool ar,
bool cf,
bool is_split)
: _source(s), _target(t), _name(n), _weight(w), _type(ty), forward(f), backward(b),
_roundabout(ra), _ignoreInGrid(ig), _accessRestricted(ar), _contraFlow(cf),
: source(s), target(t), name(n), weight(w), type(ty), forward(f), backward(b),
roundabout(ra), ignoreInGrid(ig), accessRestricted(ar), contraFlow(cf),
is_split(is_split)
{
if (ty < 0)
@ -66,24 +66,6 @@ bool NodeBasedEdge::operator<(const NodeBasedEdge &e) const
}
}
NodeID NodeBasedEdge::target() const { return _target; }
NodeID NodeBasedEdge::source() const { return _source; }
NodeID NodeBasedEdge::name() const { return _name; }
EdgeWeight NodeBasedEdge::weight() const { return _weight; }
short NodeBasedEdge::type() const
{
BOOST_ASSERT_MSG(_type >= 0, "type of ImportEdge invalid");
return _type;
}
bool NodeBasedEdge::isBackward() const { return backward; }
bool NodeBasedEdge::isForward() const { return forward; }
bool NodeBasedEdge::isLocatable() const { return _type != 14; }
bool NodeBasedEdge::isRoundabout() const { return _roundabout; }
bool NodeBasedEdge::ignoreInGrid() const { return _ignoreInGrid; }
bool NodeBasedEdge::isAccessRestricted() const { return _accessRestricted; }
bool NodeBasedEdge::isContraFlow() const { return _contraFlow; }
bool NodeBasedEdge::IsSplit() const { return is_split; }
bool EdgeBasedEdge::operator<(const EdgeBasedEdge &e) const
{
if (source() == e.source())

33
DataStructures/ImportEdge.h
View File

@ -52,32 +52,17 @@ class NodeBasedEdge
bool cf,
bool is_split);
NodeID target() const;
NodeID source() const;
NodeID name() const;
EdgeWeight weight() const;
short type() const;
bool isBackward() const;
bool isForward() const;
bool isLocatable() const;
bool isRoundabout() const;
bool ignoreInGrid() const;
bool isAccessRestricted() const;
bool isContraFlow() const;
bool IsSplit() const;
// TODO: names need to be fixed.
NodeID _source;
NodeID _target;
NodeID _name;
EdgeWeight _weight;
short _type;
NodeID source;
NodeID target;
NodeID name;
EdgeWeight weight;
short type;
bool forward : 1;
bool backward : 1;
bool _roundabout : 1;
bool _ignoreInGrid : 1;
bool _accessRestricted : 1;
bool _contraFlow : 1;
bool roundabout : 1;
bool ignoreInGrid : 1;
bool accessRestricted : 1;
bool contraFlow : 1;
bool is_split : 1;
NodeBasedEdge() = delete;

34
DataStructures/NodeBasedGraph.h
View File

@ -60,19 +60,19 @@ NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<ImportEdge
for (const ImportEdge &import_edge : input_edge_list)
{
// TODO: give ImportEdge a proper c'tor to use emplace_back's below
if (!import_edge.isForward())
if (!import_edge.forward)
{
edge.source = import_edge.target();
edge.target = import_edge.source();
edge.data.backward = import_edge.isForward();
edge.data.forward = import_edge.isBackward();
edge.source = import_edge.target;
edge.target = import_edge.source;
edge.data.backward = import_edge.forward;
edge.data.forward = import_edge.backward;
}
else
{
edge.source = import_edge.source();
edge.target = import_edge.target();
edge.data.forward = import_edge.isForward();
edge.data.backward = import_edge.isBackward();
edge.source = import_edge.source;
edge.target = import_edge.target;
edge.data.forward = import_edge.forward;
edge.data.backward = import_edge.backward;
}
if (edge.source == edge.target)
@ -80,18 +80,18 @@ NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<ImportEdge
continue;
}
edge.data.distance = (std::max)((int)import_edge.weight(), 1);
edge.data.distance = (std::max)((int)import_edge.weight, 1);
BOOST_ASSERT(edge.data.distance > 0);
edge.data.shortcut = false;
edge.data.roundabout = import_edge.isRoundabout();
edge.data.ignore_in_grid = import_edge.ignoreInGrid();
edge.data.nameID = import_edge.name();
edge.data.type = import_edge.type();
edge.data.isAccessRestricted = import_edge.isAccessRestricted();
edge.data.contraFlow = import_edge.isContraFlow();
edge.data.roundabout = import_edge.roundabout;
edge.data.ignore_in_grid = import_edge.ignoreInGrid;
edge.data.nameID = import_edge.name;
edge.data.type = import_edge.type;
edge.data.isAccessRestricted = import_edge.accessRestricted;
edge.data.contraFlow = import_edge.contraFlow;
edges_list.push_back(edge);
if (!import_edge.IsSplit())
if (!import_edge.is_split)
{
using std::swap; // enable ADL
swap(edge.source, edge.target);

38
Util/GraphLoader.h
View File

@ -207,52 +207,52 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &input_stream,
tbb::parallel_sort(edge_list.begin(), edge_list.end());
for (unsigned i = 1; i < edge_list.size(); ++i)
{
if ((edge_list[i - 1].target() == edge_list[i].target()) &&
(edge_list[i - 1].source() == edge_list[i].source()))
if ((edge_list[i - 1].target == edge_list[i].target) &&
(edge_list[i - 1].source == edge_list[i].source))
{
const bool edge_flags_equivalent =
(edge_list[i - 1].isForward() == edge_list[i].isForward()) &&
(edge_list[i - 1].isBackward() == edge_list[i].isBackward());
(edge_list[i - 1].forward == edge_list[i].forward) &&
(edge_list[i - 1].backward == edge_list[i].backward);
const bool edge_flags_are_superset1 =
(edge_list[i - 1].isForward() && edge_list[i - 1].isBackward()) &&
(edge_list[i].isBackward() != edge_list[i].isBackward());
(edge_list[i - 1].forward && edge_list[i - 1].backward) &&
(edge_list[i].backward != edge_list[i].backward);
const bool edge_flags_are_superset_2 =
(edge_list[i].isForward() && edge_list[i].isBackward()) &&
(edge_list[i - 1].isBackward() != edge_list[i - 1].isBackward());
(edge_list[i].forward && edge_list[i].backward) &&
(edge_list[i - 1].backward != edge_list[i - 1].backward);
if (edge_flags_equivalent)
{
edge_list[i]._weight = std::min(edge_list[i - 1].weight(), edge_list[i].weight());
edge_list[i - 1]._source = UINT_MAX;
edge_list[i].weight = std::min(edge_list[i - 1].weight, edge_list[i].weight);
edge_list[i - 1].source = UINT_MAX;
}
else if (edge_flags_are_superset1)
{
if (edge_list[i - 1].weight() <= edge_list[i].weight())
if (edge_list[i - 1].weight <= edge_list[i].weight)
{
// edge i-1 is smaller and goes in both directions. Throw away the other edge
edge_list[i]._source = UINT_MAX;
edge_list[i].source = UINT_MAX;
}
else
{
// edge i-1 is open in both directions, but edge i is smaller in one direction.
// Close edge i-1 in this direction
edge_list[i - 1].forward = !edge_list[i].isForward();
edge_list[i - 1].backward = !edge_list[i].isBackward();
edge_list[i - 1].forward = !edge_list[i].forward;
edge_list[i - 1].backward = !edge_list[i].backward;
}
}
else if (edge_flags_are_superset_2)
{
if (edge_list[i - 1].weight() <= edge_list[i].weight())
if (edge_list[i - 1].weight <= edge_list[i].weight)
{
// edge i-1 is smaller for one direction. edge i is open in both. close edge i
// in the other direction
edge_list[i].forward = !edge_list[i - 1].isForward();
edge_list[i].backward = !edge_list[i - 1].isBackward();
edge_list[i].forward = !edge_list[i - 1].forward;
edge_list[i].backward = !edge_list[i - 1].backward;
}
else
{
// edge i is smaller and goes in both direction. Throw away edge i-1
edge_list[i - 1]._source = UINT_MAX;
edge_list[i - 1].source = UINT_MAX;
}
}
}
@ -260,7 +260,7 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &input_stream,
const auto new_end_iter = std::remove_if(edge_list.begin(),
edge_list.end(),
[](const EdgeT &edge)
{ return edge.source() == UINT_MAX; });
{ return edge.source == SPECIAL_NODEID; });
ext_to_int_id_map.clear();
edge_list.erase(new_end_iter, edge_list.end()); // remove excess candidates.
edge_list.shrink_to_fit();