diff --git a/Algorithms/DouglasPeucker.cpp b/Algorithms/DouglasPeucker.cpp index 4ba6284a3..8b783c59a 100644 --- a/Algorithms/DouglasPeucker.cpp +++ b/Algorithms/DouglasPeucker.cpp @@ -30,33 +30,33 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "DouglasPeucker.h" #include "../DataStructures/SegmentInformation.h" -#include - #include #include -// These thresholds are more or less heuristically chosen. -static double DouglasPeuckerThresholds[19] = {262144., // z0 - 131072., // z1 - 65536., // z2 - 32768., // z3 - 16384., // z4 - 8192., // z5 - 4096., // z6 - 2048., // z7 - 960., // z8 - 480., // z9 - 240., // z10 - 90., // z11 - 50., // z12 - 25., // z13 - 15., // z14 - 5., // z15 - .65, // z16 - .5, // z17 - .35 // z18 -}; +DouglasPeucker::DouglasPeucker() + : douglas_peucker_thresholds({262144., // z0 + 131072., // z1 + 65536., // z2 + 32768., // z3 + 16384., // z4 + 8192., // z5 + 4096., // z6 + 2048., // z7 + 960., // z8 + 480., // z9 + 240., // z10 + 90., // z11 + 50., // z12 + 25., // z13 + 15., // z14 + 5., // z15 + .65, // z16 + .5, // z17 + .35 // z18 + }) +{ +} void DouglasPeucker::Run(std::vector &input_geometry, const unsigned zoom_level) { @@ -74,7 +74,7 @@ void DouglasPeucker::Run(std::vector &input_geometry, const if (input_geometry[right_border].necessary) { - recursion_stack.push(std::make_pair(left_border, right_border)); + recursion_stack.emplace(left_border, right_border); left_border = right_border; } ++right_border; @@ -100,23 +100,23 @@ void DouglasPeucker::Run(std::vector &input_geometry, const input_geometry[pair.first].location, input_geometry[pair.second].location); const double distance = std::abs(temp_dist); - if (distance > DouglasPeuckerThresholds[zoom_level] && distance > max_distance) + if (distance > douglas_peucker_thresholds[zoom_level] && distance > max_distance) { farthest_element_index = i; max_distance = distance; } } - if (max_distance > DouglasPeuckerThresholds[zoom_level]) + if (max_distance > douglas_peucker_thresholds[zoom_level]) { // mark idx as necessary input_geometry[farthest_element_index].necessary = true; if (1 < (farthest_element_index - pair.first)) { - recursion_stack.push(std::make_pair(pair.first, farthest_element_index)); + recursion_stack.emplace(pair.first, farthest_element_index); } if (1 < (pair.second - farthest_element_index)) { - recursion_stack.push(std::make_pair(farthest_element_index, pair.second)); + recursion_stack.emplace(farthest_element_index, pair.second); } } } diff --git a/Algorithms/DouglasPeucker.h b/Algorithms/DouglasPeucker.h index 4e5966467..c7527b02b 100644 --- a/Algorithms/DouglasPeucker.h +++ b/Algorithms/DouglasPeucker.h @@ -44,6 +44,8 @@ struct SegmentInformation; class DouglasPeucker { private: + std::vector douglas_peucker_thresholds; + typedef std::pair GeometryRange; // Stack to simulate the recursion std::stack recursion_stack; @@ -53,6 +55,7 @@ class DouglasPeucker const FixedPointCoordinate &segB) const; public: + DouglasPeucker(); void Run(std::vector &input_geometry, const unsigned zoom_level); }; diff --git a/Algorithms/IteratorBasedCRC32.h b/Algorithms/IteratorBasedCRC32.h index f85b70532..c651dc717 100644 --- a/Algorithms/IteratorBasedCRC32.h +++ b/Algorithms/IteratorBasedCRC32.h @@ -33,34 +33,31 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #if defined(__x86_64__) - #include +#include #else - #include // for boost::crc_32_type +#include // for boost::crc_32_type - inline void __get_cpuid( - int param, - unsigned *eax, - unsigned *ebx, - unsigned *ecx, - unsigned *edx - ) { *ecx = 0; } +inline void __get_cpuid(int param, unsigned *eax, unsigned *ebx, unsigned *ecx, unsigned *edx) +{ + *ecx = 0; +} #endif -template -class IteratorbasedCRC32 { -private: +template class IteratorbasedCRC32 +{ + private: typedef typename ContainerT::iterator IteratorType; unsigned crc; bool use_SSE42_CRC_function; #if !defined(__x86_64__) - boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> CRC32_processor; + boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> CRC32_processor; #endif - unsigned SoftwareBasedCRC32( char *str, unsigned len ) + unsigned SoftwareBasedCRC32(char *str, unsigned len) { #if !defined(__x86_64__) - CRC32_processor.process_bytes( str, len); + CRC32_processor.process_bytes(str, len); return CRC32_processor.checksum(); #else return 0; @@ -68,30 +65,28 @@ private: } // adapted from http://byteworm.com/2010/10/13/crc32/ - unsigned SSE42BasedCRC32( char *str, unsigned len ) + unsigned SSE42BasedCRC32(char *str, unsigned len) { #if defined(__x86_64__) - unsigned q = len/sizeof(unsigned); - unsigned r = len%sizeof(unsigned); - unsigned *p = (unsigned*)str; + unsigned q = len / sizeof(unsigned); + unsigned r = len % sizeof(unsigned); + unsigned *p = (unsigned *)str; - //crc=0; - while (q--) { - __asm__ __volatile__( - ".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;" - :"=S"(crc) - :"0"(crc), "c"(*p) - ); + // crc=0; + while (q--) + { + __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;" + : "=S"(crc) + : "0"(crc), "c"(*p)); ++p; } - str=(char*)p; - while (r--) { - __asm__ __volatile__( - ".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;" - :"=S"(crc) - :"0"(crc), "c"(*str) - ); + str = (char *)p; + while (r--) + { + __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;" + : "=S"(crc) + : "0"(crc), "c"(*str)); ++str; } #endif @@ -102,7 +97,7 @@ private: { unsigned eax = 0, ebx = 0, ecx = 0, edx = 0; // on X64 this calls hardware cpuid(.) instr. otherwise a dummy impl. - __get_cpuid( 1, &eax, &ebx, &ecx, &edx ); + __get_cpuid(1, &eax, &ebx, &ecx, &edx); return ecx; } @@ -111,33 +106,34 @@ private: static const int SSE42_BIT = 0x00100000; const unsigned ecx = cpuid(); const bool has_SSE42 = ecx & SSE42_BIT; - if (has_SSE42) { + if (has_SSE42) + { SimpleLogger().Write() << "using hardware based CRC32 computation"; - } else { + } + else + { SimpleLogger().Write() << "using software based CRC32 computation"; } return has_SSE42; } -public: - IteratorbasedCRC32() : crc(0) - { - use_SSE42_CRC_function = DetectNativeCRC32Support(); - } + public: + IteratorbasedCRC32() : crc(0) { use_SSE42_CRC_function = DetectNativeCRC32Support(); } - unsigned operator()( IteratorType iter, const IteratorType end ) + unsigned operator()(IteratorType iter, const IteratorType end) { unsigned crc = 0; - while(iter != end) { - char * data = reinterpret_cast(&(*iter) ); + while (iter != end) + { + char *data = reinterpret_cast(&(*iter)); if (use_SSE42_CRC_function) { - crc = SSE42BasedCRC32( data, sizeof(typename ContainerT::value_type) ); + crc = SSE42BasedCRC32(data, sizeof(typename ContainerT::value_type)); } else { - crc = SoftwareBasedCRC32( data, sizeof(typename ContainerT::value_type) ); + crc = SoftwareBasedCRC32(data, sizeof(typename ContainerT::value_type)); } ++iter; } diff --git a/Algorithms/ObjectToBase64.h b/Algorithms/ObjectToBase64.h index d0dfe3cb3..2599283c3 100644 --- a/Algorithms/ObjectToBase64.h +++ b/Algorithms/ObjectToBase64.h @@ -34,7 +34,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include -#include #include #include diff --git a/Algorithms/PolylineCompressor.cpp b/Algorithms/PolylineCompressor.cpp index acab45656..76d93823f 100644 --- a/Algorithms/PolylineCompressor.cpp +++ b/Algorithms/PolylineCompressor.cpp @@ -27,87 +27,99 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "PolylineCompressor.h" -void PolylineCompressor::encodeVectorSignedNumber( - std::vector & numbers, - std::string & output -) const { - for(unsigned i = 0; i < numbers.size(); ++i) { +void PolylineCompressor::encodeVectorSignedNumber(std::vector &numbers, std::string &output) + const +{ + const unsigned end = numbers.size(); + for (unsigned i = 0; i < end; ++i) + { numbers[i] <<= 1; - if (numbers[i] < 0) { + if (numbers[i] < 0) + { numbers[i] = ~(numbers[i]); } } - for(unsigned i = 0; i < numbers.size(); ++i) { + for (unsigned i = 0; i < end; ++i) + { encodeNumber(numbers[i], output); } } -void PolylineCompressor::encodeNumber(int number_to_encode, std::string & output) const { - while (number_to_encode >= 0x20) { - int nextValue = (0x20 | (number_to_encode & 0x1f)) + 63; - output += static_cast(nextValue); - if(92 == nextValue) { - output += static_cast(nextValue); +void PolylineCompressor::encodeNumber(int number_to_encode, std::string &output) const +{ + while (number_to_encode >= 0x20) + { + int next_value = (0x20 | (number_to_encode & 0x1f)) + 63; + output += static_cast(next_value); + if (92 == next_value) + { + output += static_cast(next_value); } number_to_encode >>= 5; } number_to_encode += 63; output += static_cast(number_to_encode); - if(92 == number_to_encode) { + if (92 == number_to_encode) + { output += static_cast(number_to_encode); } } -void PolylineCompressor::printEncodedString( - const std::vector & polyline, - std::string & output -) const { - std::vector deltaNumbers; +void PolylineCompressor::printEncodedString(const std::vector &polyline, + std::string &output) const +{ + std::vector delta_numbers; output += "\""; - if(!polyline.empty()) { - FixedPointCoordinate lastCoordinate = polyline[0].location; - deltaNumbers.push_back( lastCoordinate.lat ); - deltaNumbers.push_back( lastCoordinate.lon ); - for(unsigned i = 1; i < polyline.size(); ++i) { - if(!polyline[i].necessary) { - continue; + if (!polyline.empty()) + { + FixedPointCoordinate last_coordinate = polyline[0].location; + delta_numbers.emplace_back(last_coordinate.lat); + delta_numbers.emplace_back(last_coordinate.lon); + for (unsigned i = 1; i < polyline.size(); ++i) + { + if (polyline[i].necessary) + { + int lat_diff = polyline[i].location.lat - last_coordinate.lat; + int lon_diff = polyline[i].location.lon - last_coordinate.lon; + delta_numbers.emplace_back(lat_diff); + delta_numbers.emplace_back(lon_diff); + last_coordinate = polyline[i].location; } - deltaNumbers.push_back(polyline[i].location.lat - lastCoordinate.lat); - deltaNumbers.push_back(polyline[i].location.lon - lastCoordinate.lon); - lastCoordinate = polyline[i].location; } - encodeVectorSignedNumber(deltaNumbers, output); - } - output += "\""; - -} - -void PolylineCompressor::printEncodedString( - const std::vector& polyline, - std::string &output -) const { - std::vector deltaNumbers(2*polyline.size()); - output += "\""; - if(!polyline.empty()) { - deltaNumbers[0] = polyline[0].lat; - deltaNumbers[1] = polyline[0].lon; - for(unsigned i = 1; i < polyline.size(); ++i) { - deltaNumbers[(2*i)] = (polyline[i].lat - polyline[i-1].lat); - deltaNumbers[(2*i)+1] = (polyline[i].lon - polyline[i-1].lon); - } - encodeVectorSignedNumber(deltaNumbers, output); + encodeVectorSignedNumber(delta_numbers, output); } output += "\""; } -void PolylineCompressor::printUnencodedString( - const std::vector & polyline, - std::string & output -) const { +void PolylineCompressor::printEncodedString(const std::vector &polyline, + std::string &output) const +{ + std::vector delta_numbers(2 * polyline.size()); + output += "\""; + if (!polyline.empty()) + { + delta_numbers[0] = polyline[0].lat; + delta_numbers[1] = polyline[0].lon; + for (unsigned i = 1; i < polyline.size(); ++i) + { + int lat_diff = polyline[i].lat - polyline[i - 1].lat; + int lon_diff = polyline[i].lon - polyline[i - 1].lon; + delta_numbers[(2 * i)] = (lat_diff); + delta_numbers[(2 * i) + 1] = (lon_diff); + } + encodeVectorSignedNumber(delta_numbers, output); + } + output += "\""; +} + +void PolylineCompressor::printUnencodedString(const std::vector &polyline, + std::string &output) const +{ output += "["; std::string tmp; - for(unsigned i = 0; i < polyline.size(); i++) { + for (unsigned i = 0; i < polyline.size(); i++) + { FixedPointCoordinate::convertInternalLatLonToString(polyline[i].lat, tmp); output += "["; output += tmp; @@ -115,21 +127,23 @@ void PolylineCompressor::printUnencodedString( output += ", "; output += tmp; output += "]"; - if( i < polyline.size()-1 ) { + if (i < polyline.size() - 1) + { output += ","; } } output += "]"; } -void PolylineCompressor::printUnencodedString( - const std::vector & polyline, - std::string & output -) const { +void PolylineCompressor::printUnencodedString(const std::vector &polyline, + std::string &output) const +{ output += "["; std::string tmp; - for(unsigned i = 0; i < polyline.size(); i++) { - if(!polyline[i].necessary) { + for (unsigned i = 0; i < polyline.size(); i++) + { + if (!polyline[i].necessary) + { continue; } FixedPointCoordinate::convertInternalLatLonToString(polyline[i].location.lat, tmp); @@ -139,7 +153,8 @@ void PolylineCompressor::printUnencodedString( output += ", "; output += tmp; output += "]"; - if( i < polyline.size()-1 ) { + if (i < polyline.size() - 1) + { output += ","; } } diff --git a/Algorithms/PolylineCompressor.h b/Algorithms/PolylineCompressor.h index fda9cee13..2860e2e65 100644 --- a/Algorithms/PolylineCompressor.h +++ b/Algorithms/PolylineCompressor.h @@ -34,36 +34,25 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -class PolylineCompressor { -private: - void encodeVectorSignedNumber( - std::vector & numbers, - std::string & output - ) const; +class PolylineCompressor +{ + private: + void encodeVectorSignedNumber(std::vector &numbers, std::string &output) const; - void encodeNumber(int number_to_encode, std::string & output) const; + void encodeNumber(int number_to_encode, std::string &output) const; -public: - void printEncodedString( - const std::vector & polyline, - std::string & output - ) const; + public: + void printEncodedString(const std::vector &polyline, + std::string &output) const; - void printEncodedString( - const std::vector& polyline, - std::string &output - ) const; + void printEncodedString(const std::vector &polyline, + std::string &output) const; - void printUnencodedString( - const std::vector & polyline, - std::string & output - ) const; - - void printUnencodedString( - const std::vector & polyline, - std::string & output - ) const; + void printUnencodedString(const std::vector &polyline, + std::string &output) const; + void printUnencodedString(const std::vector &polyline, + std::string &output) const; }; #endif /* POLYLINECOMPRESSOR_H_ */ diff --git a/Algorithms/StronglyConnectedComponents.h b/Algorithms/StronglyConnectedComponents.h index e94ea7ac3..bb9645363 100644 --- a/Algorithms/StronglyConnectedComponents.h +++ b/Algorithms/StronglyConnectedComponents.h @@ -28,6 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef STRONGLYCONNECTEDCOMPONENTS_H_ #define STRONGLYCONNECTEDCOMPONENTS_H_ +#include "../typedefs.h" #include "../DataStructures/DeallocatingVector.h" #include "../DataStructures/DynamicGraph.h" #include "../DataStructures/ImportEdge.h" @@ -42,185 +43,178 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -#include #include -#include -#include -#include #ifdef __APPLE__ - #include - #include +#include +#include #else - #include - #include +#include +#include #endif +#include #include +#include +#include #include -class TarjanSCC { -private: +namespace std +{ +template <> struct hash> +{ + size_t operator()(const std::pair &pair) const + { + return std::hash()(pair.first) ^ std::hash()(pair.second); + } +}; +} - struct TarjanNode { - TarjanNode() : index(UINT_MAX), lowlink(UINT_MAX), onStack(false) {} +class TarjanSCC +{ + private: + struct TarjanNode + { + TarjanNode() : index(UINT_MAX), low_link(UINT_MAX), on_stack(false) {} unsigned index; - unsigned lowlink; - bool onStack; + unsigned low_link; + bool on_stack; }; - struct TarjanEdgeData { + struct TarjanEdgeData + { int distance; - unsigned nameID:31; - bool shortcut:1; + unsigned name_id : 31; + bool shortcut : 1; short type; - bool isAccessRestricted:1; - bool forward:1; - bool backward:1; - bool roundabout:1; - bool ignoreInGrid:1; - bool reversedEdge:1; + bool forward : 1; + bool backward : 1; + bool reversedEdge : 1; }; - struct TarjanStackFrame { - explicit TarjanStackFrame( - NodeID v, - NodeID parent - ) : v(v), parent(parent) { } + struct TarjanStackFrame + { + explicit TarjanStackFrame(NodeID v, NodeID parent) : v(v), parent(parent) {} NodeID v; NodeID parent; }; - typedef DynamicGraph TarjanDynamicGraph; - typedef TarjanDynamicGraph::InputEdge TarjanEdge; - typedef std::pair RestrictionSource; - typedef std::pair restriction_target; - typedef std::vector EmanatingRestrictionsVector; - typedef boost::unordered_map RestrictionMap; + typedef DynamicGraph TarjanDynamicGraph; + typedef TarjanDynamicGraph::InputEdge TarjanEdge; + typedef std::pair RestrictionSource; + typedef std::pair restriction_target; + typedef std::vector EmanatingRestrictionsVector; + typedef std::unordered_map RestrictionMap; - std::vector m_coordinate_list; - std::vector m_restriction_bucket_list; - boost::shared_ptr m_node_based_graph; - boost::unordered_set m_barrier_node_list; - boost::unordered_set m_traffic_light_list; - unsigned m_restriction_counter; - RestrictionMap m_restriction_map; + std::vector m_coordinate_list; + std::vector m_restriction_bucket_list; + std::shared_ptr m_node_based_graph; + std::unordered_set m_barrier_node_list; + std::unordered_set m_traffic_light_list; + unsigned m_restriction_counter; + RestrictionMap m_restriction_map; - struct EdgeBasedNode { - bool operator<(const EdgeBasedNode & other) const { - return other.id < id; - } - bool operator==(const EdgeBasedNode & other) const { - return id == other.id; - } - NodeID id; - int lat1; - int lat2; - int lon1; - int lon2:31; - bool belongsToTinyComponent:1; - NodeID nameID; - unsigned weight:31; - bool ignoreInGrid:1; - }; - -public: - TarjanSCC( - int number_of_nodes, - std::vector & input_edges, - std::vector & bn, - std::vector & tl, - std::vector & irs, - std::vector & nI - ) : - m_coordinate_list(nI), - m_restriction_counter(irs.size()) + public: + TarjanSCC(int number_of_nodes, + std::vector &input_edges, + std::vector &bn, + std::vector &tl, + std::vector &irs, + std::vector &nI) + : m_coordinate_list(nI), m_restriction_counter(irs.size()) { - BOOST_FOREACH(const TurnRestriction & restriction, irs) { - std::pair restrictionSource = std::make_pair( - restriction.fromNode, restriction.viaNode - ); + for (const TurnRestriction &restriction : irs) + { + std::pair restrictionSource = {restriction.fromNode, + restriction.viaNode}; unsigned index; - RestrictionMap::iterator restriction_iterator = m_restriction_map.find(restrictionSource); - if(restriction_iterator == m_restriction_map.end()) { + RestrictionMap::iterator restriction_iterator = + m_restriction_map.find(restrictionSource); + if (restriction_iterator == m_restriction_map.end()) + { index = m_restriction_bucket_list.size(); - m_restriction_bucket_list.resize(index+1); - m_restriction_map.insert(std::make_pair(restrictionSource, index)); - } else { + m_restriction_bucket_list.resize(index + 1); + m_restriction_map.emplace(restrictionSource, index); + } + else + { index = restriction_iterator->second; - //Map already contains an is_only_*-restriction - if(m_restriction_bucket_list.at(index).begin()->second) { + // Map already contains an is_only_*-restriction + if (m_restriction_bucket_list.at(index).begin()->second) + { continue; - } else if(restriction.flags.isOnly) { - //We are going to insert an is_only_*-restriction. There can be only one. + } + else if (restriction.flags.isOnly) + { + // We are going to insert an is_only_*-restriction. There can be only one. m_restriction_bucket_list.at(index).clear(); } } - m_restriction_bucket_list.at(index).push_back( - std::make_pair(restriction.toNode, restriction.flags.isOnly) - ); + m_restriction_bucket_list.at(index) + .emplace_back(restriction.toNode, restriction.flags.isOnly); } m_barrier_node_list.insert(bn.begin(), bn.end()); m_traffic_light_list.insert(tl.begin(), tl.end()); - DeallocatingVector< TarjanEdge > edge_list; - BOOST_FOREACH(const NodeBasedEdge & input_edge, input_edges) { + DeallocatingVector edge_list; + for (const NodeBasedEdge &input_edge : input_edges) + { + if (input_edge.source() == input_edge.target()) + { + continue; + } + TarjanEdge edge; - if(!input_edge.isForward()) { - edge.source = input_edge.target(); - edge.target = input_edge.source(); - edge.data.backward = input_edge.isForward(); - edge.data.forward = input_edge.isBackward(); - } else { + if (input_edge.isForward()) + { edge.source = input_edge.source(); edge.target = input_edge.target(); edge.data.forward = input_edge.isForward(); edge.data.backward = input_edge.isBackward(); } - if(edge.source == edge.target) { - continue; + else + { + edge.source = input_edge.target(); + edge.target = input_edge.source(); + edge.data.backward = input_edge.isForward(); + edge.data.forward = input_edge.isBackward(); } - edge.data.distance = (std::max)((int)input_edge.weight(), 1 ); - BOOST_ASSERT( edge.data.distance > 0 ); + 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.nameID = input_edge.name(); + // 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.isAccessRestricted = input_edge.isAccessRestricted(); edge.data.reversedEdge = false; - edge_list.push_back( edge ); - if( edge.data.backward ) { - std::swap( edge.source, edge.target ); + 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.reversedEdge = true; - edge_list.push_back( edge ); + edge_list.push_back(edge); } } std::vector().swap(input_edges); - BOOST_ASSERT_MSG( - 0 == input_edges.size() && 0 == input_edges.capacity(), - "input edge vector not properly deallocated" - ); + 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() ); + std::sort(edge_list.begin(), edge_list.end()); - m_node_based_graph = boost::make_shared( - number_of_nodes, - edge_list - ); + m_node_based_graph = std::make_shared(number_of_nodes, edge_list); } - ~TarjanSCC() { - m_node_based_graph.reset(); - } + ~TarjanSCC() { m_node_based_graph.reset(); } - void Run() { - //remove files from previous run if exist + void Run() + { + // remove files from previous run if exist DeleteFileIfExists("component.dbf"); DeleteFileIfExists("component.shx"); DeleteFileIfExists("component.shp"); @@ -230,121 +224,108 @@ public: OGRRegisterAll(); const char *pszDriverName = "ESRI Shapefile"; - OGRSFDriver * poDriver = OGRSFDriverRegistrar::GetRegistrar()-> - GetDriverByName( pszDriverName ); - if( NULL == poDriver ) { + OGRSFDriver *poDriver = + OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName); + if (NULL == poDriver) + { throw OSRMException("ESRI Shapefile driver not available"); } - OGRDataSource * poDS = poDriver->CreateDataSource( - "component.shp", - NULL - ); + OGRDataSource *poDS = poDriver->CreateDataSource("component.shp", NULL); - if( NULL == poDS ) { + if (NULL == poDS) + { throw OSRMException("Creation of output file failed"); } - OGRLayer * poLayer = poDS->CreateLayer( - "component", - NULL, - wkbLineString, - NULL - ); + OGRLayer *poLayer = poDS->CreateLayer("component", NULL, wkbLineString, NULL); - if( NULL == poLayer ) { + if (NULL == poLayer) + { throw OSRMException("Layer creation failed."); } - //The following is a hack to distinguish between stuff that happens - //before the recursive call and stuff that happens after - std::stack > recursion_stack; - //true = stuff before, false = stuff after call + // The following is a hack to distinguish between stuff that happens + // before the recursive call and stuff that happens after + std::stack> recursion_stack; + // true = stuff before, false = stuff after call std::stack tarjan_stack; - std::vector components_index( - m_node_based_graph->GetNumberOfNodes(), - UINT_MAX - ); + std::vector components_index(m_node_based_graph->GetNumberOfNodes(), UINT_MAX); std::vector component_size_vector; - std::vector tarjan_node_list( - m_node_based_graph->GetNumberOfNodes() - ); + std::vector tarjan_node_list(m_node_based_graph->GetNumberOfNodes()); unsigned component_index = 0, size_of_current_component = 0; int index = 0; - for( - NodeID node = 0, last_node = m_node_based_graph->GetNumberOfNodes(); - node < last_node; - ++node - ) { - if(UINT_MAX == components_index[node]) { - recursion_stack.push( - std::make_pair(true, TarjanStackFrame(node,node)) - ); + NodeID last_node = m_node_based_graph->GetNumberOfNodes(); + for (NodeID node = 0; node < last_node; ++node) + { + if (UINT_MAX == components_index[node]) + { + recursion_stack.emplace(true, TarjanStackFrame(node, node)); } - while(!recursion_stack.empty()) { - bool before_recursion = recursion_stack.top().first; + while (!recursion_stack.empty()) + { + const bool before_recursion = recursion_stack.top().first; TarjanStackFrame currentFrame = recursion_stack.top().second; NodeID v = currentFrame.v; recursion_stack.pop(); - if(before_recursion) { - //Mark frame to handle tail of recursion - recursion_stack.push(std::make_pair(false, currentFrame)); + if (before_recursion) + { + // Mark frame to handle tail of recursion + recursion_stack.emplace(false, currentFrame); - //Mark essential information for SCC + // Mark essential information for SCC tarjan_node_list[v].index = index; - tarjan_node_list[v].lowlink = index; + tarjan_node_list[v].low_link = index; tarjan_stack.push(v); - tarjan_node_list[v].onStack = true; + tarjan_node_list[v].on_stack = true; ++index; - //Traverse outgoing edges - for( - TarjanDynamicGraph::EdgeIterator e2 = m_node_based_graph->BeginEdges(v); - e2 < m_node_based_graph->EndEdges(v); - ++e2 - ) { + // Traverse outgoing edges + EdgeID end_edge = m_node_based_graph->EndEdges(v); + for (auto e2 = m_node_based_graph->BeginEdges(v); e2 < end_edge; ++e2) + { const TarjanDynamicGraph::NodeIterator vprime = m_node_based_graph->GetTarget(e2); - if(UINT_MAX == tarjan_node_list[vprime].index) { - recursion_stack.push( - std::make_pair( - true, - TarjanStackFrame(vprime, v) - ) - ); - } else { - if( - tarjan_node_list[vprime].onStack && - tarjan_node_list[vprime].index < tarjan_node_list[v].lowlink - ) { - tarjan_node_list[v].lowlink = tarjan_node_list[vprime].index; + if (UINT_MAX == tarjan_node_list[vprime].index) + { + recursion_stack.emplace(true, TarjanStackFrame(vprime, v)); + } + else + { + if (tarjan_node_list[vprime].on_stack && + tarjan_node_list[vprime].index < tarjan_node_list[v].low_link) + { + tarjan_node_list[v].low_link = tarjan_node_list[vprime].index; } } } - } else { - tarjan_node_list[currentFrame.parent].lowlink = - std::min( - tarjan_node_list[currentFrame.parent].lowlink, - tarjan_node_list[v].lowlink - ); - //after recursion, lets do cycle checking - //Check if we found a cycle. This is the bottom part of the recursion - if(tarjan_node_list[v].lowlink == tarjan_node_list[v].index) { + } + else + { + tarjan_node_list[currentFrame.parent].low_link = + std::min(tarjan_node_list[currentFrame.parent].low_link, + tarjan_node_list[v].low_link); + // after recursion, lets do cycle checking + // Check if we found a cycle. This is the bottom part of the recursion + if (tarjan_node_list[v].low_link == tarjan_node_list[v].index) + { NodeID vprime; - do { - vprime = tarjan_stack.top(); tarjan_stack.pop(); - tarjan_node_list[vprime].onStack = false; + do + { + vprime = tarjan_stack.top(); + tarjan_stack.pop(); + tarjan_node_list[vprime].on_stack = false; components_index[vprime] = component_index; ++size_of_current_component; - } while( v != vprime); + } while (v != vprime); - component_size_vector.push_back(size_of_current_component); + component_size_vector.emplace_back(size_of_current_component); - if(size_of_current_component > 1000) { - SimpleLogger().Write() << - "large component [" << component_index << "]=" << - size_of_current_component; + if (size_of_current_component > 1000) + { + SimpleLogger().Write() << "large component [" << component_index + << "]=" << size_of_current_component; } ++component_index; @@ -354,115 +335,99 @@ public: } } - SimpleLogger().Write() << - "identified: " << component_size_vector.size() << - " many components, marking small components"; + SimpleLogger().Write() << "identified: " << component_size_vector.size() + << " many components, marking small components"; // TODO/C++11: prime candidate for lambda function unsigned size_one_counter = 0; - for(unsigned i = 0, end = component_size_vector.size(); i < end; ++i){ - if(1 == component_size_vector[i]) { + for (unsigned i = 0, end = component_size_vector.size(); i < end; ++i) + { + if (1 == component_size_vector[i]) + { ++size_one_counter; } } - SimpleLogger().Write() << - "identified " << size_one_counter << " SCCs of size 1"; + SimpleLogger().Write() << "identified " << size_one_counter << " SCCs of size 1"; uint64_t total_network_distance = 0; p.reinit(m_node_based_graph->GetNumberOfNodes()); - for( - TarjanDynamicGraph::NodeIterator u = 0, last_u_node = m_node_based_graph->GetNumberOfNodes(); - u < last_u_node; - ++u - ) { + NodeID last_u_node = m_node_based_graph->GetNumberOfNodes(); + for (auto u = 0; u < last_u_node; ++u) + { p.printIncrement(); - for( - TarjanDynamicGraph::EdgeIterator e1 = m_node_based_graph->BeginEdges(u), last_edge = m_node_based_graph->EndEdges(u); - e1 < last_edge; - ++e1 - ) { - if(!m_node_based_graph->GetEdgeData(e1).reversedEdge) { + EdgeID last_edge = m_node_based_graph->EndEdges(u); + for (auto e1 = m_node_based_graph->BeginEdges(u); e1 < last_edge; ++e1) + { + if (!m_node_based_graph->GetEdgeData(e1).reversedEdge) + { continue; } const TarjanDynamicGraph::NodeIterator v = m_node_based_graph->GetTarget(e1); - total_network_distance += 100*FixedPointCoordinate::ApproximateDistance( - m_coordinate_list[u].lat, - m_coordinate_list[u].lon, - m_coordinate_list[v].lat, - m_coordinate_list[v].lon - ); + total_network_distance += + 100 * FixedPointCoordinate::ApproximateDistance(m_coordinate_list[u].lat, + m_coordinate_list[u].lon, + m_coordinate_list[v].lat, + m_coordinate_list[v].lon); - if( SHRT_MAX != m_node_based_graph->GetEdgeData(e1).type ) { + if (SHRT_MAX != m_node_based_graph->GetEdgeData(e1).type) + { BOOST_ASSERT(e1 != UINT_MAX); BOOST_ASSERT(u != UINT_MAX); BOOST_ASSERT(v != UINT_MAX); const unsigned size_of_containing_component = - std::min( - component_size_vector[components_index[u]], - component_size_vector[components_index[v]] - ); + std::min(component_size_vector[components_index[u]], + component_size_vector[components_index[v]]); - //edges that end on bollard nodes may actually be in two distinct components - if(size_of_containing_component < 10) { + // edges that end on bollard nodes may actually be in two distinct components + if (size_of_containing_component < 10) + { OGRLineString lineString; - lineString.addPoint( - m_coordinate_list[u].lon/COORDINATE_PRECISION, - m_coordinate_list[u].lat/COORDINATE_PRECISION - ); - lineString.addPoint( - m_coordinate_list[v].lon/COORDINATE_PRECISION, - m_coordinate_list[v].lat/COORDINATE_PRECISION - ); + lineString.addPoint(m_coordinate_list[u].lon / COORDINATE_PRECISION, + m_coordinate_list[u].lat / COORDINATE_PRECISION); + lineString.addPoint(m_coordinate_list[v].lon / COORDINATE_PRECISION, + m_coordinate_list[v].lat / COORDINATE_PRECISION); - OGRFeature * poFeature = OGRFeature::CreateFeature( - poLayer->GetLayerDefn() - ); + OGRFeature *poFeature = OGRFeature::CreateFeature(poLayer->GetLayerDefn()); - poFeature->SetGeometry( &lineString ); - if( OGRERR_NONE != poLayer->CreateFeature(poFeature) ) { - throw OSRMException( - "Failed to create feature in shapefile." - ); + poFeature->SetGeometry(&lineString); + if (OGRERR_NONE != poLayer->CreateFeature(poFeature)) + { + throw OSRMException("Failed to create feature in shapefile."); } - OGRFeature::DestroyFeature( poFeature ); + OGRFeature::DestroyFeature(poFeature); } } } } - OGRDataSource::DestroyDataSource( poDS ); + OGRDataSource::DestroyDataSource(poDS); std::vector().swap(component_size_vector); - BOOST_ASSERT_MSG( - 0 == component_size_vector.size() && - 0 == component_size_vector.capacity(), - "component_size_vector not properly deallocated" - ); + BOOST_ASSERT_MSG(0 == component_size_vector.size() && 0 == component_size_vector.capacity(), + "component_size_vector not properly deallocated"); std::vector().swap(components_index); - BOOST_ASSERT_MSG( - 0 == components_index.size() && 0 == components_index.capacity(), - "icomponents_index not properly deallocated" - ); + BOOST_ASSERT_MSG(0 == components_index.size() && 0 == components_index.capacity(), + "icomponents_index not properly deallocated"); - SimpleLogger().Write() - << "total network distance: " << - (uint64_t)total_network_distance/100/1000. << - " km"; + SimpleLogger().Write() << "total network distance: " << (uint64_t)total_network_distance / + 100 / 1000. << " km"; } -private: - unsigned CheckForEmanatingIsOnlyTurn(const NodeID u, const NodeID v) const { - std::pair < NodeID, NodeID > restriction_source = std::make_pair(u, v); - RestrictionMap::const_iterator restriction_iterator = m_restriction_map.find(restriction_source); - if (restriction_iterator != m_restriction_map.end()) { + private: + unsigned CheckForEmanatingIsOnlyTurn(const NodeID u, const NodeID v) const + { + std::pair restriction_source = {u, v}; + RestrictionMap::const_iterator restriction_iterator = + m_restriction_map.find(restriction_source); + if (restriction_iterator != m_restriction_map.end()) + { const unsigned index = restriction_iterator->second; - BOOST_FOREACH( - const RestrictionSource & restriction_target, - m_restriction_bucket_list.at(index) - ) { - if(restriction_target.second) { + for (const RestrictionSource &restriction_target : m_restriction_bucket_list.at(index)) + { + if (restriction_target.second) + { return restriction_target.first; } } @@ -470,21 +435,19 @@ private: return UINT_MAX; } - bool CheckIfTurnIsRestricted( - const NodeID u, - const NodeID v, - const NodeID w - ) const { - //only add an edge if turn is not a U-turn except it is the end of dead-end street. - std::pair < NodeID, NodeID > restriction_source = std::make_pair(u, v); - RestrictionMap::const_iterator restriction_iterator = m_restriction_map.find(restriction_source); - if (restriction_iterator != m_restriction_map.end()) { + bool CheckIfTurnIsRestricted(const NodeID u, const NodeID v, const NodeID w) const + { + // only add an edge if turn is not a U-turn except it is the end of dead-end street. + std::pair restriction_source = {u, v}; + RestrictionMap::const_iterator restriction_iterator = + m_restriction_map.find(restriction_source); + if (restriction_iterator != m_restriction_map.end()) + { const unsigned index = restriction_iterator->second; - BOOST_FOREACH( - const restriction_target & restriction_target, - m_restriction_bucket_list.at(index) - ) { - if(w == restriction_target.first) { + for (const restriction_target &restriction_target : m_restriction_bucket_list.at(index)) + { + if (w == restriction_target.first) + { return true; } } @@ -492,8 +455,10 @@ private: return false; } - void DeleteFileIfExists(const std::string & file_name) const { - if (boost::filesystem::exists(file_name) ) { + void DeleteFileIfExists(const std::string &file_name) const + { + if (boost::filesystem::exists(file_name)) + { boost::filesystem::remove(file_name); } } diff --git a/Tools/componentAnalysis.cpp b/Tools/componentAnalysis.cpp index 3f216b71b..8fb8e92c2 100644 --- a/Tools/componentAnalysis.cpp +++ b/Tools/componentAnalysis.cpp @@ -27,8 +27,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../typedefs.h" #include "../Algorithms/StronglyConnectedComponents.h" -#include "../DataStructures/BinaryHeap.h" -#include "../DataStructures/DeallocatingVector.h" #include "../DataStructures/DynamicGraph.h" #include "../DataStructures/QueryEdge.h" #include "../DataStructures/TurnInstructions.h" @@ -38,11 +36,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../Util/SimpleLogger.h" #include "../Util/UUID.h" -#include #include -#include -#include -#include +#include #include #include @@ -98,9 +93,12 @@ int main(int argc, char *argv[]) } std::vector edge_list; - NodeID node_based_node_count = readBinaryOSRMGraphFromStream( - input_stream, edge_list, bollard_node_IDs_vector, traffic_light_node_IDs_vector, - &internal_to_external_node_map, restrictions_vector); + const NodeID node_based_node_count = readBinaryOSRMGraphFromStream(input_stream, + edge_list, + bollard_node_IDs_vector, + traffic_light_node_IDs_vector, + &internal_to_external_node_map, + restrictions_vector); input_stream.close(); BOOST_ASSERT_MSG(restrictions_vector.size() == usable_restriction_count, @@ -116,16 +114,15 @@ int main(int argc, char *argv[]) */ SimpleLogger().Write() << "Starting SCC graph traversal"; - TarjanSCC *tarjan = new TarjanSCC(node_based_node_count, edge_list, bollard_node_IDs_vector, - traffic_light_node_IDs_vector, restrictions_vector, + std::shared_ptr tarjan = std::make_shared(node_based_node_count, + edge_list, + bollard_node_IDs_vector, + traffic_light_node_IDs_vector, + restrictions_vector, internal_to_external_node_map); std::vector().swap(edge_list); tarjan->Run(); - - std::vector().swap(restrictions_vector); - std::vector().swap(bollard_node_IDs_vector); - std::vector().swap(traffic_light_node_IDs_vector); SimpleLogger().Write() << "finished component analysis"; } catch (const std::exception &e)