From cf5c776990486d878254a48109d69122e46bf836 Mon Sep 17 00:00:00 2001 From: DennisOSRM Date: Fri, 18 Jan 2013 21:28:13 +0100 Subject: [PATCH] Implementing logic when route is going against one-way flow (think bikes!) --- Contractor/EdgeBasedGraphFactory.cpp | 15 ++++++- Contractor/EdgeBasedGraphFactory.h | 63 ++++++++++++++-------------- DataStructures/ImportEdge.h | 16 ++++--- Extractor/ExtractionContainers.cpp | 9 ++-- Extractor/ExtractionContainers.h | 2 +- Extractor/ExtractorCallbacks.cpp | 18 ++++---- Extractor/ExtractorCallbacks.h | 2 +- Extractor/ExtractorStructs.h | 62 +++++++++++++-------------- Extractor/PBFParser.cpp | 8 ++-- Extractor/PBFParser.h | 2 +- Extractor/ScriptingEnvironment.cpp | 24 +++++------ Extractor/XMLParser.cpp | 6 +-- Extractor/XMLParser.h | 4 +- Util/GraphLoader.h | 5 ++- extractor.cpp | 4 +- 15 files changed, 125 insertions(+), 115 deletions(-) diff --git a/Contractor/EdgeBasedGraphFactory.cpp b/Contractor/EdgeBasedGraphFactory.cpp index 994c4cc07..b6bc1e437 100644 --- a/Contractor/EdgeBasedGraphFactory.cpp +++ b/Contractor/EdgeBasedGraphFactory.cpp @@ -79,6 +79,7 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vectortype(); edge.data.isAccessRestricted = i->isAccessRestricted(); edge.data.edgeBasedNodeID = edges.size(); + edge.data.contraFlow = i->isContraFlow(); edges.push_back( edge ); if( edge.data.backward ) { std::swap( edge.source, edge.target ); @@ -342,6 +343,13 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID u, const NodeID _NodeBasedDynamicGraph::EdgeData & data1 = _nodeBasedGraph->GetEdgeData(edge1); _NodeBasedDynamicGraph::EdgeData & data2 = _nodeBasedGraph->GetEdgeData(edge2); + if(!data1.contraFlow && data2.contraFlow) { + return TurnInstructions.EnterAgainstAllowedDirection; + } + if(data1.contraFlow && !data2.contraFlow) { + return TurnInstructions.LeaveAgainstAllowedDirection; + } + //roundabouts need to be handled explicitely if(data1.roundabout && data2.roundabout) { //Is a turn possible? If yes, we stay on the roundabout! @@ -363,10 +371,13 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID u, const NodeID } //If street names stay the same and if we are certain that it is not a roundabout, we skip it. - if( (data1.nameID == data2.nameID) && (0 != data1.nameID)) + if( (data1.nameID == data2.nameID) && (0 != data1.nameID)) { return TurnInstructions.NoTurn; - if( (data1.nameID == data2.nameID) && (0 == data1.nameID) && (_nodeBasedGraph->GetOutDegree(v) <= 2) ) + } + if( (data1.nameID == data2.nameID) && (0 == data1.nameID) && (_nodeBasedGraph->GetOutDegree(v) <= 2) ) { + ERR("should not happen"); return TurnInstructions.NoTurn; + } double angle = GetAngleBetweenTwoEdges(inputNodeInfoList[u], inputNodeInfoList[v], inputNodeInfoList[w]); return TurnInstructions.GetTurnDirectionOfInstruction(angle); diff --git a/Contractor/EdgeBasedGraphFactory.h b/Contractor/EdgeBasedGraphFactory.h index 2b4c18d7f..d4cc91888 100644 --- a/Contractor/EdgeBasedGraphFactory.h +++ b/Contractor/EdgeBasedGraphFactory.h @@ -34,6 +34,7 @@ #include #include #include +#include #include @@ -48,34 +49,7 @@ #include "../DataStructures/TurnInstructions.h" #include "../Util/BaseConfiguration.h" -class EdgeBasedGraphFactory { -private: - struct _NodeBasedEdgeData { - int distance; - unsigned edgeBasedNodeID; - unsigned nameID; - short type; - bool isAccessRestricted; - bool shortcut:1; - bool forward:1; - bool backward:1; - bool roundabout:1; - bool ignoreInGrid:1; - }; - - struct _EdgeBasedEdgeData { - int distance; - unsigned via; - unsigned nameID; - bool forward; - bool backward; - TurnInstruction turnInstruction; - }; - - typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph; - typedef _NodeBasedDynamicGraph::InputEdge _NodeBasedEdge; - std::vector inputNodeInfoList; - unsigned numberOfTurnRestrictions; +class EdgeBasedGraphFactory : boost::noncopyable { public: struct EdgeBasedNode { bool operator<(const EdgeBasedNode & other) const { @@ -95,13 +69,41 @@ public: bool ignoreInGrid:1; }; - struct SpeedProfileProperties{ SpeedProfileProperties() : trafficSignalPenalty(0), uTurnPenalty(0) {} int trafficSignalPenalty; int uTurnPenalty; } speedProfile; + private: + struct _NodeBasedEdgeData { + int distance; + unsigned edgeBasedNodeID; + unsigned nameID; + short type; + bool isAccessRestricted; + bool shortcut:1; + bool forward:1; + bool backward:1; + bool roundabout:1; + bool ignoreInGrid:1; + bool contraFlow; + }; + + struct _EdgeBasedEdgeData { + int distance; + unsigned via; + unsigned nameID; + bool forward; + bool backward; + TurnInstruction turnInstruction; + }; + + typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph; + typedef _NodeBasedDynamicGraph::InputEdge _NodeBasedEdge; + std::vector inputNodeInfoList; + unsigned numberOfTurnRestrictions; + boost::shared_ptr<_NodeBasedDynamicGraph> _nodeBasedGraph; boost::unordered_map _barrierNodes; boost::unordered_map _trafficLights; @@ -113,7 +115,6 @@ private: std::vector _restrictionBucketVector; RestrictionMap _restrictionMap; - DeallocatingVector edgeBasedEdges; DeallocatingVector edgeBasedNodes; std::vector originalEdgeData; @@ -127,8 +128,6 @@ private: bool belongsToTinyComponent); template double GetAngleBetweenTwoEdges(const CoordinateT& A, const CoordinateT& C, const CoordinateT& B) const; -// SRTMLookup srtmLookup; - public: template< class InputEdgeT > diff --git a/DataStructures/ImportEdge.h b/DataStructures/ImportEdge.h index a90cd474d..1b5966c40 100644 --- a/DataStructures/ImportEdge.h +++ b/DataStructures/ImportEdge.h @@ -40,12 +40,8 @@ public: return (source() < e.source()); } - /** Default constructor. target and weight are set to 0.*/ - NodeBasedEdge() : - _source(0), _target(0), _name(0), _weight(0), forward(0), backward(0), _type(0), _roundabout(false), _ignoreInGrid(false), _accessRestricted(false) { assert(false); } //shall not be used. - - explicit NodeBasedEdge(NodeID s, NodeID t, NodeID n, EdgeWeight w, bool f, bool b, short ty, bool ra, bool ig, bool ar) : - _source(s), _target(t), _name(n), _weight(w), forward(f), backward(b), _type(ty), _roundabout(ra), _ignoreInGrid(ig), _accessRestricted(ar) { if(ty < 0) {ERR("Type: " << ty);}; } + explicit NodeBasedEdge(NodeID s, NodeID t, NodeID n, EdgeWeight w, bool f, bool b, short ty, bool ra, bool ig, bool ar, bool cf) : + _source(s), _target(t), _name(n), _weight(w), forward(f), backward(b), _type(ty), _roundabout(ra), _ignoreInGrid(ig), _accessRestricted(ar), _contraFlow(cf) { if(ty < 0) {ERR("Type: " << ty);}; } NodeID target() const {return _target; } NodeID source() const {return _source; } @@ -59,6 +55,7 @@ public: bool isRoundabout() const { return _roundabout; } bool ignoreInGrid() const { return _ignoreInGrid; } bool isAccessRestricted() const { return _accessRestricted; } + bool isContraFlow() const { return _contraFlow; } NodeID _source; NodeID _target; @@ -70,6 +67,13 @@ public: bool _roundabout; bool _ignoreInGrid; bool _accessRestricted; + bool _contraFlow; + +private: + /** Default constructor. target and weight are set to 0.*/ + NodeBasedEdge() : + _source(0), _target(0), _name(0), _weight(0), forward(0), backward(0), _type(0), _roundabout(false), _ignoreInGrid(false), _accessRestricted(false), _contraFlow(false) { assert(false); } //shall not be used. + }; class EdgeBasedEdge { diff --git a/Extractor/ExtractionContainers.cpp b/Extractor/ExtractionContainers.cpp index 93a0fd674..b2476bc86 100644 --- a/Extractor/ExtractionContainers.cpp +++ b/Extractor/ExtractionContainers.cpp @@ -231,17 +231,17 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const fout.write((char*)&edgeIT->target, sizeof(unsigned)); fout.write((char*)&intDist, sizeof(int)); switch(edgeIT->direction) { - case _Way::notSure: + case ExtractionWay::notSure: fout.write((char*)&zero, sizeof(short)); break; - case _Way::oneway: + case ExtractionWay::oneway: fout.write((char*)&one, sizeof(short)); break; - case _Way::bidirectional: + case ExtractionWay::bidirectional: fout.write((char*)&zero, sizeof(short)); break; - case _Way::opposite: + case ExtractionWay::opposite: fout.write((char*)&one, sizeof(short)); break; default: @@ -256,6 +256,7 @@ void ExtractionContainers::PrepareData(const std::string & outputFileName, const fout.write((char*)&edgeIT->isRoundabout, sizeof(bool)); fout.write((char*)&edgeIT->ignoreInGrid, sizeof(bool)); fout.write((char*)&edgeIT->isAccessRestricted, sizeof(bool)); + fout.write((char*)&edgeIT->isContraFlow, sizeof(bool)); } ++usedEdgeCounter; ++edgeIT; diff --git a/Extractor/ExtractionContainers.h b/Extractor/ExtractionContainers.h index 7e8a1d7be..abf718d5f 100644 --- a/Extractor/ExtractionContainers.h +++ b/Extractor/ExtractionContainers.h @@ -31,7 +31,7 @@ class ExtractionContainers { public: typedef stxxl::vector STXXLNodeIDVector; typedef stxxl::vector<_Node> STXXLNodeVector; - typedef stxxl::vector<_Edge> STXXLEdgeVector; + typedef stxxl::vector STXXLEdgeVector; typedef stxxl::vector STXXLStringVector; typedef stxxl::vector<_RawRestrictionContainer> STXXLRestrictionsVector; typedef stxxl::vector<_WayIDStartAndEndEdge> STXXLWayIDStartEndVector; diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index 75da55032..6a5ee1c14 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -64,7 +64,7 @@ bool ExtractorCallbacks::restrictionFunction(_RawRestrictionContainer &r) { } /** warning: caller needs to take care of synchronization! */ -bool ExtractorCallbacks::wayFunction(_Way &parsed_way) { +bool ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) { if ( parsed_way.speed > 0 ) { //Only true if the way is specified by the speed profile if(parsed_way.id == UINT_MAX){ WARN("found bogus way with id: " << parsed_way.id << " of size " << parsed_way.path.size()); @@ -80,20 +80,20 @@ bool ExtractorCallbacks::wayFunction(_Way &parsed_way) { parsed_way.nameID = string_map_iterator->second; } - if ( parsed_way.direction == _Way::opposite ){ + if ( parsed_way.direction == ExtractionWay::opposite ){ std::reverse( parsed_way.path.begin(), parsed_way.path.end() ); } - if( parsed_way.backward_speed > 0 && parsed_way.direction == _Way::bidirectional) { - parsed_way.direction == _Way::oneway; + if( parsed_way.backward_speed > 0 && parsed_way.direction == ExtractionWay::bidirectional) { + parsed_way.direction = ExtractionWay::oneway; } for(std::vector< NodeID >::size_type n = 0; n < parsed_way.path.size()-1; ++n) { externalMemory->allEdges.push_back( - _Edge(parsed_way.path[n], + InternalExtractorEdge(parsed_way.path[n], parsed_way.path[n+1], parsed_way.type, - (_Way::bidirectional == parsed_way.direction && parsed_way.backward_speed > 0 ? _Way::oneway : parsed_way.direction), + (ExtractionWay::bidirectional == parsed_way.direction && parsed_way.backward_speed > 0 ? ExtractionWay::oneway : parsed_way.direction), parsed_way.speed, parsed_way.nameID, parsed_way.roundabout, @@ -113,17 +113,17 @@ bool ExtractorCallbacks::wayFunction(_Way &parsed_way) { std::reverse( parsed_way.path.begin(), parsed_way.path.end() ); for(std::vector< NodeID >::size_type n = 0; n < parsed_way.path.size()-1; ++n) { externalMemory->allEdges.push_back( - _Edge(parsed_way.path[n], + InternalExtractorEdge(parsed_way.path[n], parsed_way.path[n+1], parsed_way.type, - _Way::oneway, + ExtractionWay::oneway, parsed_way.backward_speed, parsed_way.nameID, parsed_way.roundabout, parsed_way.ignoreInGrid, parsed_way.isDurationSet, parsed_way.isAccessRestricted, - (_Way::oneway == parsed_way.direction) + (ExtractionWay::oneway == parsed_way.direction) ) ); } diff --git a/Extractor/ExtractorCallbacks.h b/Extractor/ExtractorCallbacks.h index 70f812ec2..3ddbbe841 100644 --- a/Extractor/ExtractorCallbacks.h +++ b/Extractor/ExtractorCallbacks.h @@ -50,7 +50,7 @@ public: bool restrictionFunction(_RawRestrictionContainer &r); /** warning: caller needs to take care of synchronization! */ - bool wayFunction(_Way &w); + bool wayFunction(ExtractionWay &w); }; diff --git a/Extractor/ExtractorStructs.h b/Extractor/ExtractorStructs.h index ad508fdaf..c1ccbfe6e 100644 --- a/Extractor/ExtractorStructs.h +++ b/Extractor/ExtractorStructs.h @@ -40,8 +40,8 @@ or see http://www.gnu.org/licenses/agpl.txt. typedef boost::unordered_map StringMap; typedef boost::unordered_map > StringToIntPairMap; -struct _Way { - _Way() { +struct ExtractionWay { + ExtractionWay() { Clear(); } @@ -50,7 +50,7 @@ struct _Way { nameID = UINT_MAX; path.clear(); keyVals.EraseAll(); - direction = _Way::notSure; + direction = ExtractionWay::notSure; speed = -1; backward_speed = -1; type = -1; @@ -79,22 +79,22 @@ struct _Way { HashTable keyVals; }; -struct _Relation { - _Relation() : type(unknown){} +struct ExtractorRelation { + ExtractorRelation() : type(unknown){} enum { unknown = 0, ferry, turnRestriction } type; HashTable keyVals; }; -struct _Edge { - _Edge() : start(0), target(0), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) {}; - _Edge(NodeID s, NodeID t) : start(s), target(t), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { } - _Edge(NodeID s, NodeID t, short tp, short d, double sp): start(s), target(t), type(tp), direction(d), speed(sp), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { } - _Edge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(false) { +struct InternalExtractorEdge { + InternalExtractorEdge() : start(0), target(0), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) {}; + InternalExtractorEdge(NodeID s, NodeID t) : start(s), target(t), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { } + InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp): start(s), target(t), type(tp), direction(d), speed(sp), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { } + InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(false) { assert(0 <= type); } - _Edge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar, bool icf): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(icf) { + InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar, bool icf): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(icf) { assert(0 <= type); } NodeID start; @@ -112,15 +112,16 @@ struct _Edge { _Coordinate startCoord; _Coordinate targetCoord; - static _Edge min_value() { - return _Edge(0,0); + static InternalExtractorEdge min_value() { + return InternalExtractorEdge(0,0); } - static _Edge max_value() { - return _Edge((std::numeric_limits::max)(), (std::numeric_limits::max)()); + static InternalExtractorEdge max_value() { + return InternalExtractorEdge((std::numeric_limits::max)(), (std::numeric_limits::max)()); } - }; + + struct _WayIDStartAndEndEdge { unsigned wayID; NodeID firstStart; @@ -177,34 +178,29 @@ struct CmpNodeByID : public std::binary_function<_Node, _Node, bool> { } }; -struct CmpEdgeByStartID : public std::binary_function<_Edge, _Edge, bool> -{ - typedef _Edge value_type; - bool operator () (const _Edge & a, const _Edge & b) const { +struct CmpEdgeByStartID : public std::binary_function { + typedef InternalExtractorEdge value_type; + bool operator () (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const { return a.start < b.start; } value_type max_value() { - return _Edge::max_value(); + return InternalExtractorEdge::max_value(); } value_type min_value() { - return _Edge::min_value(); + return InternalExtractorEdge::min_value(); } }; -struct CmpEdgeByTargetID : public std::binary_function<_Edge, _Edge, bool> -{ - typedef _Edge value_type; - bool operator () (const _Edge & a, const _Edge & b) const - { +struct CmpEdgeByTargetID : public std::binary_function { + typedef InternalExtractorEdge value_type; + bool operator () (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const { return a.target < b.target; } - value_type max_value() - { - return _Edge::max_value(); + value_type max_value() { + return InternalExtractorEdge::max_value(); } - value_type min_value() - { - return _Edge::min_value(); + value_type min_value() { + return InternalExtractorEdge::min_value(); } }; diff --git a/Extractor/PBFParser.cpp b/Extractor/PBFParser.cpp index d86fbc457..222475db6 100644 --- a/Extractor/PBFParser.cpp +++ b/Extractor/PBFParser.cpp @@ -332,8 +332,8 @@ inline void PBFParser::parseRelation(_ThreadData * threadData) { } inline void PBFParser::parseWay(_ThreadData * threadData) { - _Way w; - std::vector<_Way> waysToParse(threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways_size()); + ExtractionWay w; + std::vector waysToParse(threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways_size()); for(int i = 0, ways_size = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways_size(); i < ways_size; ++i) { w.Clear(); const OSMPBF::Way& inputWay = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways( i ); @@ -356,7 +356,7 @@ inline void PBFParser::parseWay(_ThreadData * threadData) { unsigned endi_ways = waysToParse.size(); #pragma omp parallel for schedule ( guided ) for(unsigned i = 0; i < endi_ways; ++i) { - _Way & w = waysToParse[i]; + ExtractionWay & w = waysToParse[i]; /** Pass the unpacked way to the LUA call back **/ try { luabind::call_function( @@ -376,7 +376,7 @@ inline void PBFParser::parseWay(_ThreadData * threadData) { // } } - BOOST_FOREACH(_Way & w, waysToParse) { + BOOST_FOREACH(ExtractionWay & w, waysToParse) { if(!externalMemory->wayFunction(w)) { std::cerr << "[PBFParser] way not parsed" << std::endl; } diff --git a/Extractor/PBFParser.h b/Extractor/PBFParser.h index ed469272d..d3da02706 100644 --- a/Extractor/PBFParser.h +++ b/Extractor/PBFParser.h @@ -41,7 +41,7 @@ #include "ExtractorStructs.h" #include "ScriptingEnvironment.h" -class PBFParser : public BaseParser { +class PBFParser : public BaseParser { enum EntityType { TypeNode = 1, diff --git a/Extractor/ScriptingEnvironment.cpp b/Extractor/ScriptingEnvironment.cpp index b4b6af54e..ca8d9a754 100644 --- a/Extractor/ScriptingEnvironment.cpp +++ b/Extractor/ScriptingEnvironment.cpp @@ -65,19 +65,19 @@ ScriptingEnvironment::ScriptingEnvironment(const char * fileName) { ]; luabind::module(myLuaState) [ - luabind::class_<_Way>("Way") + luabind::class_("Way") .def(luabind::constructor<>()) - .def_readwrite("name", &_Way::name) - .def_readwrite("backward_speed", &_Way::backward_speed) - .def_readwrite("speed", &_Way::speed) - .def_readwrite("type", &_Way::type) - .def_readwrite("access", &_Way::access) - .def_readwrite("roundabout", &_Way::roundabout) - .def_readwrite("is_duration_set", &_Way::isDurationSet) - .def_readwrite("is_access_restricted", &_Way::isAccessRestricted) - .def_readwrite("ignore_in_grid", &_Way::ignoreInGrid) - .def_readwrite("tags", &_Way::keyVals) - .def_readwrite("direction", &_Way::direction) + .def_readwrite("name", &ExtractionWay::name) + .def_readwrite("backward_speed", &ExtractionWay::backward_speed) + .def_readwrite("speed", &ExtractionWay::speed) + .def_readwrite("type", &ExtractionWay::type) + .def_readwrite("access", &ExtractionWay::access) + .def_readwrite("roundabout", &ExtractionWay::roundabout) + .def_readwrite("is_duration_set", &ExtractionWay::isDurationSet) + .def_readwrite("is_access_restricted", &ExtractionWay::isAccessRestricted) + .def_readwrite("ignore_in_grid", &ExtractionWay::ignoreInGrid) + .def_readwrite("tags", &ExtractionWay::keyVals) + .def_readwrite("direction", &ExtractionWay::direction) .enum_("constants") [ luabind::value("notSure", 0), diff --git a/Extractor/XMLParser.cpp b/Extractor/XMLParser.cpp index 6449add3f..5faa5a71e 100644 --- a/Extractor/XMLParser.cpp +++ b/Extractor/XMLParser.cpp @@ -100,7 +100,7 @@ bool XMLParser::Parse() { } if ( xmlStrEqual( currentName, ( const xmlChar* ) "way" ) == 1 ) { - _Way way = _ReadXMLWay( ); + ExtractionWay way = _ReadXMLWay( ); /** Pass the unpacked way to the LUA call back **/ try { @@ -222,8 +222,8 @@ _RawRestrictionContainer XMLParser::_ReadXMLRestriction() { return restriction; } -_Way XMLParser::_ReadXMLWay() { - _Way way; +ExtractionWay XMLParser::_ReadXMLWay() { + ExtractionWay way; if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) { const int depth = xmlTextReaderDepth( inputReader ); while ( xmlTextReaderRead( inputReader ) == 1 ) { diff --git a/Extractor/XMLParser.h b/Extractor/XMLParser.h index d87c50145..3bc54825d 100644 --- a/Extractor/XMLParser.h +++ b/Extractor/XMLParser.h @@ -28,7 +28,7 @@ #include "ExtractorCallbacks.h" #include "ScriptingEnvironment.h" -class XMLParser : public BaseParser { +class XMLParser : public BaseParser { public: XMLParser(const char * filename); virtual ~XMLParser(); @@ -39,7 +39,7 @@ public: private: _RawRestrictionContainer _ReadXMLRestriction(); - _Way _ReadXMLWay(); + ExtractionWay _ReadXMLWay(); ImportNode _ReadXMLNode( ); /* Input Reader */ xmlTextReaderPtr inputReader; diff --git a/Util/GraphLoader.h b/Util/GraphLoader.h index b22086c39..40bc98a9c 100644 --- a/Util/GraphLoader.h +++ b/Util/GraphLoader.h @@ -101,7 +101,7 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &in, std::vector& edgeL short type; NodeID nameID; int length; - bool isRoundabout, ignoreInGrid, isAccessRestricted; + bool isRoundabout, ignoreInGrid, isAccessRestricted, isContraFlow; for (EdgeID i=0; i& edgeL in.read((char*)&isRoundabout, sizeof(bool)); in.read((char*)&ignoreInGrid, sizeof(bool)); in.read((char*)&isAccessRestricted, sizeof(bool)); + in.read((char*)&isContraFlow, sizeof(bool)); GUARANTEE(length > 0, "loaded null length edge" ); GUARANTEE(weight > 0, "loaded null weight"); @@ -150,7 +151,7 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &in, std::vector& edgeL std::swap(forward, backward); } - EdgeT inputEdge(source, target, nameID, weight, forward, backward, type, isRoundabout, ignoreInGrid, isAccessRestricted ); + EdgeT inputEdge(source, target, nameID, weight, forward, backward, type, isRoundabout, ignoreInGrid, isAccessRestricted, isContraFlow ); edgeList.push_back(inputEdge); } std::sort(edgeList.begin(), edgeList.end()); diff --git a/extractor.cpp b/extractor.cpp index d212a837e..1aa72f83b 100644 --- a/extractor.cpp +++ b/extractor.cpp @@ -58,7 +58,6 @@ int main (int argc, char *argv[]) { } omp_set_num_threads(numberOfThreads); - INFO("extracting data from input file " << argv[1]); bool isPBF(false); std::string outputFileName(argv[1]); @@ -93,10 +92,9 @@ int main (int argc, char *argv[]) { StringMap stringMap; ExtractionContainers externalMemory; - stringMap[""] = 0; extractCallBacks = new ExtractorCallbacks(&externalMemory, &stringMap); - BaseParser * parser; + BaseParser * parser; if(isPBF) { parser = new PBFParser(argv[1]); } else {