From 752fb880be74d194e7e72fc7e5b0139ed9d3307c Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 28 Mar 2014 17:13:00 +0100 Subject: [PATCH] switch edge-expanded street name indexes to be first segment names (18 failed tests left) --- Contractor/EdgeBasedGraphFactory.cpp | 19 +++-- DataStructures/PhantomNodes.h | 12 ++- DataStructures/RawRouteData.h | 11 ++- DataStructures/StaticRTree.h | 6 +- Descriptors/DescriptionFactory.cpp | 80 +++++++++++------- Descriptors/DescriptionFactory.h | 14 ++-- Descriptors/JSONDescriptor.h | 94 ++++++++++++++++++++-- RoutingAlgorithms/AlternativePathRouting.h | 11 ++- RoutingAlgorithms/BasicRoutingInterface.h | 19 +++-- RoutingAlgorithms/ShortestPathRouting.h | 13 ++- 10 files changed, 202 insertions(+), 77 deletions(-) diff --git a/Contractor/EdgeBasedGraphFactory.cpp b/Contractor/EdgeBasedGraphFactory.cpp index 89cf6d63b..dfa6c30a3 100644 --- a/Contractor/EdgeBasedGraphFactory.cpp +++ b/Contractor/EdgeBasedGraphFactory.cpp @@ -318,14 +318,6 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode( BOOST_ASSERT( m_geometry_compressor.HasEntryForID(e1) == m_geometry_compressor.HasEntryForID(e2) ); if( m_geometry_compressor.HasEntryForID(e1) ) { - if(forward_data.edgeBasedNodeID == 16176) { - SimpleLogger().Write(logDEBUG) << "reverse_data.edgeBasedNodeID=" << reverse_data.edgeBasedNodeID; - SimpleLogger().Write(logDEBUG) << "u: " << u << ", v: " << v << " at " << m_node_info_list.at(u).lat/COORDINATE_PRECISION << "," - << m_node_info_list.at(u).lon/COORDINATE_PRECISION << "<->" << m_node_info_list.at(v).lat/COORDINATE_PRECISION << "," - << m_node_info_list.at(v).lon/COORDINATE_PRECISION; - SimpleLogger().Write(logDEBUG) << "pos(" << e1 << ")=" << m_geometry_compressor.GetPositionForID(e1); - SimpleLogger().Write(logDEBUG) << "pos(" << e2 << ")=" << m_geometry_compressor.GetPositionForID(e2); - } BOOST_ASSERT( m_geometry_compressor.HasEntryForID(e2) ); @@ -605,6 +597,7 @@ void EdgeBasedGraphFactory::Run( forward_weight1 + (add_traffic_signal_penalty ? speed_profile.trafficSignalPenalty :0), forward_weight2 ); + SimpleLogger().Write(logDEBUG) << "compressing fwd segment with name " << m_node_based_graph->GetEdgeData(forward_e1).nameID; m_geometry_compressor.CompressEdge( reverse_e1, reverse_e2, @@ -613,8 +606,14 @@ void EdgeBasedGraphFactory::Run( reverse_weight1 , reverse_weight2 + (add_traffic_signal_penalty ? speed_profile.trafficSignalPenalty :0) ); - + SimpleLogger().Write(logDEBUG) << "compressing rev segment with name " << m_node_based_graph->GetEdgeData(reverse_e1).nameID; ++removed_node_count; + + BOOST_ASSERT + ( + m_node_based_graph->GetEdgeData(forward_e1).nameID == + m_node_based_graph->GetEdgeData(reverse_e1).nameID + ); } } SimpleLogger().Write() << "removed " << removed_node_count << " nodes"; @@ -840,7 +839,7 @@ void EdgeBasedGraphFactory::Run( original_edge_data_vector.push_back( OriginalEdgeData( (edge_is_compressed ? m_geometry_compressor.GetPositionForID(e1) : v), - edge_data2.nameID, + (edge_is_compressed ? edge_data1.nameID : edge_data1.nameID), turn_instruction, edge_is_compressed ) diff --git a/DataStructures/PhantomNodes.h b/DataStructures/PhantomNodes.h index 5396c3e60..4aeead635 100644 --- a/DataStructures/PhantomNodes.h +++ b/DataStructures/PhantomNodes.h @@ -42,7 +42,6 @@ struct PhantomNode { forward_offset(0), reverse_offset(0), packed_geometry_id(SPECIAL_EDGEID), - ratio(0.), fwd_segment_position(0) { } @@ -54,11 +53,10 @@ struct PhantomNode { int forward_offset; int reverse_offset; unsigned packed_geometry_id; - double ratio; + // double ratio; FixedPointCoordinate location; unsigned short fwd_segment_position; - int GetForwardWeightPlusOffset() const { SimpleLogger().Write(logDEBUG) << "->fwd_offset: " << forward_offset << ", weight: " << forward_weight; @@ -79,7 +77,7 @@ struct PhantomNode { reverse_weight = INVALID_EDGE_WEIGHT; forward_offset = 0; reverse_offset = 0; - ratio = 0.; + // ratio = 0.; location.Reset(); } @@ -106,8 +104,8 @@ struct PhantomNode { (forward_weight != INVALID_EDGE_WEIGHT) || (reverse_weight != INVALID_EDGE_WEIGHT) ) && - (ratio >= 0.) && - (ratio <= 1.) && + // (ratio >= 0.) && + // (ratio <= 1.) && (name_id != std::numeric_limits::max() ); } @@ -162,7 +160,7 @@ inline std::ostream& operator<<(std::ostream &out, const PhantomNode & pn) { "rev-w: " << pn.reverse_weight << ", " << "fwd-o: " << pn.forward_offset << ", " << "rev-o: " << pn.reverse_offset << ", " << - "ratio: " << pn.ratio << ", " << + // "ratio: " << pn.ratio << ", " << "geom: " << pn.packed_geometry_id << ", " << "pos: " << pn.fwd_segment_position << ", " << "loc: " << pn.location; diff --git a/DataStructures/RawRouteData.h b/DataStructures/RawRouteData.h index 509c4ca97..cedbc2d76 100644 --- a/DataStructures/RawRouteData.h +++ b/DataStructures/RawRouteData.h @@ -70,10 +70,19 @@ struct RawRouteData { unsigned checkSum; int lengthOfShortestPath; int lengthOfAlternativePath; + bool source_traversed_in_reverse; + bool target_traversed_in_reverse; + bool alt_source_traversed_in_reverse; + bool alt_target_traversed_in_reverse; + RawRouteData() : checkSum(UINT_MAX), lengthOfShortestPath(INT_MAX), - lengthOfAlternativePath(INT_MAX) + lengthOfAlternativePath(INT_MAX), + source_traversed_in_reverse(false), + target_traversed_in_reverse(false), + alt_source_traversed_in_reverse(false), + alt_target_traversed_in_reverse(false) { } }; diff --git a/DataStructures/StaticRTree.h b/DataStructures/StaticRTree.h index 738564547..699603617 100644 --- a/DataStructures/StaticRTree.h +++ b/DataStructures/StaticRTree.h @@ -771,12 +771,12 @@ public: { result_phantom_node.reverse_weight *= 1.-ratio; } - result_phantom_node.ratio = ratio; + // result_phantom_node.ratio = ratio; SimpleLogger().Write(logDEBUG) << "result location: " << result_phantom_node.location << ", start: " << current_start_coordinate << ", end: " << current_end_coordinate; SimpleLogger().Write(logDEBUG) << "fwd node: " << result_phantom_node.forward_node_id << ", rev node: " << result_phantom_node.reverse_node_id; - SimpleLogger().Write(logDEBUG) << "fwd weight: " << result_phantom_node.forward_weight << ", rev weight: " << result_phantom_node.reverse_weight << ", ratio: " << result_phantom_node.ratio; - SimpleLogger().Write(logDEBUG) << "fwd offset: " << result_phantom_node.forward_offset << ", rev offset: " << result_phantom_node.reverse_offset << ", ratio: " << result_phantom_node.ratio; + SimpleLogger().Write(logDEBUG) << "fwd weight: " << result_phantom_node.forward_weight << ", rev weight: " << result_phantom_node.reverse_weight;// << ", ratio: " << result_phantom_node.ratio; + SimpleLogger().Write(logDEBUG) << "fwd offset: " << result_phantom_node.forward_offset << ", rev offset: " << result_phantom_node.reverse_offset;// << ", ratio: " << result_phantom_node.ratio; SimpleLogger().Write(logDEBUG) << "bidirected: " << (result_phantom_node.isBidirected() ? "y" : "n"); SimpleLogger().Write(logDEBUG) << "name id: " << result_phantom_node.name_id; SimpleLogger().Write(logDEBUG) << "geom id: " << result_phantom_node.packed_geometry_id; diff --git a/Descriptors/DescriptionFactory.cpp b/Descriptors/DescriptionFactory.cpp index 2b2842282..9e84e3be8 100644 --- a/Descriptors/DescriptionFactory.cpp +++ b/Descriptors/DescriptionFactory.cpp @@ -31,18 +31,18 @@ DescriptionFactory::DescriptionFactory() : entireLength(0) { } DescriptionFactory::~DescriptionFactory() { } -inline double DescriptionFactory::DegreeToRadian(const double degree) const { - return degree * (M_PI/180); +inline double DescriptionFactory::DegreeToRadian(const double degree) const +{ + return degree * (M_PI/180.); } -inline double DescriptionFactory::RadianToDegree(const double radian) const { - return radian * (180/M_PI); +inline double DescriptionFactory::RadianToDegree(const double radian) const +{ + return radian * (180./M_PI); } -double DescriptionFactory::GetBearing( - const FixedPointCoordinate & A, - const FixedPointCoordinate & B -) const { +double DescriptionFactory::GetBearing(const FixedPointCoordinate & A, const FixedPointCoordinate & B) const +{ double delta_long = DegreeToRadian(B.lon/COORDINATE_PRECISION - A.lon/COORDINATE_PRECISION); const double lat1 = DegreeToRadian(A.lat/COORDINATE_PRECISION); @@ -51,24 +51,42 @@ double DescriptionFactory::GetBearing( const double y = sin(delta_long) * cos(lat2); const double x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(delta_long); double result = RadianToDegree(atan2(y, x)); - while(result < 0.) { + while (result < 0.) + { result += 360.; } - while(result >= 360.) { + + while (result >= 360.) + { result -= 360.; } return result; } -void DescriptionFactory::SetStartSegment(const PhantomNode & start) { - start_phantom = start; +void DescriptionFactory::SetStartSegment(const PhantomNode & source, const bool source_traversed_in_reverse) +{ + int fwd_weight = source.forward_weight; + int rev_weight = source.reverse_weight; + int fwd_offset = source.forward_offset; + int rev_offset = source.reverse_offset; + SimpleLogger().Write(logDEBUG) << "df source, traversed in reverse: " << (source_traversed_in_reverse ? "y" : "n") << ", location: " << source.location << ", fwd_weight: " << fwd_weight << ", fwd_offset: " << fwd_offset << ", rev_weight: " << rev_weight << ", rev_offset: " << rev_offset; + SimpleLogger().Write(logDEBUG) << "duration of first segment: " << (source_traversed_in_reverse ? source.GetReverseWeightPlusOffset() : source.GetForwardWeightPlusOffset()); + start_phantom = source; AppendSegment( - start.location, - PathData(0, start.name_id, 10, start.forward_weight) + source.location, + PathData(0, source.name_id, 10, source.forward_weight) ); } -void DescriptionFactory::SetEndSegment(const PhantomNode & target) { +void DescriptionFactory::SetEndSegment(const PhantomNode & target, const bool target_traversed_in_reverse) +{ + int fwd_weight = target.forward_weight; + int rev_weight = target.reverse_weight; + int fwd_offset = target.forward_offset; + int rev_offset = target.reverse_offset; + SimpleLogger().Write(logDEBUG) << "df target, traversed in reverse: " << (target_traversed_in_reverse ? "y" : "n") << ", location: " << target.location << ", fwd_weight: " << fwd_weight << ", fwd_offset: " << fwd_offset << ", rev_weight: " << rev_weight << ", rev_offset: " << rev_offset; + SimpleLogger().Write(logDEBUG) << "duration of last segment: " << (target_traversed_in_reverse ? target.GetReverseWeightPlusOffset() : target.GetForwardWeightPlusOffset()); + target_phantom = target; pathDescription.push_back( SegmentInformation( @@ -86,22 +104,22 @@ void DescriptionFactory::AppendSegment( const FixedPointCoordinate & coordinate, const PathData & data ) { - if( - ( 1 == pathDescription.size()) && - ( pathDescription.back().location == coordinate) - ) { - pathDescription.back().name_id = data.name_id; - } else { - pathDescription.push_back( - SegmentInformation( - coordinate, - data.name_id, - data.durationOfSegment, - 0, - data.turnInstruction - ) - ); - } + // if( + // ( 1 == pathDescription.size()) && + // ( pathDescription.back().location == coordinate) + // ) { + // pathDescription.back().name_id = data.name_id; + // } else { + pathDescription.push_back( + SegmentInformation( + coordinate, + data.name_id, + data.durationOfSegment, + 0, + data.turnInstruction + ) + ); + // } } void DescriptionFactory::AppendEncodedPolylineString( diff --git a/Descriptors/DescriptionFactory.h b/Descriptors/DescriptionFactory.h index d06cf58f9..e011b2cd2 100644 --- a/Descriptors/DescriptionFactory.h +++ b/Descriptors/DescriptionFactory.h @@ -87,8 +87,8 @@ public: void AppendUnencodedPolylineString(std::vector &output) const; void AppendSegment(const FixedPointCoordinate & coordinate, const PathData & data); void BuildRouteSummary(const double distance, const unsigned time); - void SetStartSegment(const PhantomNode & start_phantom); - void SetEndSegment(const PhantomNode & start_phantom); + void SetStartSegment(const PhantomNode & start_phantom, const bool source_traversed_in_reverse); + void SetEndSegment(const PhantomNode & start_phantom, const bool target_traversed_in_reverse); void AppendEncodedPolylineString( const bool return_encoded, std::vector & output @@ -105,15 +105,17 @@ public: /** starts at index 1 */ pathDescription[0].length = 0; - for(unsigned i = 1; i < pathDescription.size(); ++i) + for (unsigned i = 1; i < pathDescription.size(); ++i) { + //move down names by one, q&d hack + pathDescription[i-1].name_id = pathDescription[i].name_id; pathDescription[i].length = FixedPointCoordinate::ApproximateEuclideanDistance(pathDescription[i-1].location, pathDescription[i].location); } for (unsigned i = 0; i < pathDescription.size(); ++i) { const std::string name = facade->GetEscapedNameForNameID(pathDescription[0].name_id); - SimpleLogger().Write(logDEBUG) << "[" << i << "] name: " << name << ", duration: " << pathDescription[i].duration << ", length: " << pathDescription[i].length << ", coordinate: " << pathDescription[i].location; + SimpleLogger().Write(logDEBUG) << "df [" << i << "] name: " << name << ", duration: " << pathDescription[i].duration << ", length: " << pathDescription[i].length << ", coordinate: " << pathDescription[i].location; } /*Simplify turn instructions @@ -186,7 +188,7 @@ public: target_phantom.name_id = (pathDescription.end()-2)->name_id; } } else { - pathDescription[segment_start_index].duration *= (1.-target_phantom.ratio); + // pathDescription[segment_start_index].duration *= (1.-target_phantom.ratio); } if(std::numeric_limits::epsilon() > pathDescription[0].length) { if(pathDescription.size() > 2) { @@ -196,7 +198,7 @@ public: start_phantom.name_id = pathDescription[0].name_id; } } else { - pathDescription[0].duration *= start_phantom.ratio; + // pathDescription[0].duration *= start_phantom.ratio; } //Generalize poly line diff --git a/Descriptors/JSONDescriptor.h b/Descriptors/JSONDescriptor.h index cd5cebc99..ba3f84594 100644 --- a/Descriptors/JSONDescriptor.h +++ b/Descriptors/JSONDescriptor.h @@ -99,7 +99,7 @@ public: FixedPointCoordinate current_coordinate; BOOST_FOREACH(const PathData & path_data, route_leg) { current_coordinate = facade->GetCoordinateOfNode(path_data.node); - description_factory.AppendSegment(current_coordinate, path_data ); + description_factory.AppendSegment(current_coordinate, path_data); ++added_element_count; } // description_factory.SetEndSegment( leg_phantoms.target_phantom ); @@ -120,7 +120,8 @@ public: "{\"status\":" ); - if(INT_MAX == raw_route.lengthOfShortestPath) { + if (INVALID_EDGE_WEIGHT == raw_route.lengthOfShortestPath) + { //We do not need to do much, if there is no route ;-) reply.content.push_back( "207,\"status_message\": \"Cannot find route between points\"}" @@ -128,12 +129,87 @@ public: return; } - description_factory.SetStartSegment(phantom_nodes.source_phantom); + std::string name = facade->GetEscapedNameForNameID(phantom_nodes.source_phantom.name_id); + int fwd_weight = phantom_nodes.source_phantom.forward_weight; + int rev_weight = phantom_nodes.source_phantom.reverse_weight; + int fwd_offset = phantom_nodes.source_phantom.forward_offset; + int rev_offset = phantom_nodes.source_phantom.reverse_offset; + SimpleLogger().Write(logDEBUG) << "json source: " << name << ", location: " << phantom_nodes.source_phantom.location << ", fwd_weight: " << fwd_weight << ", fwd_offset: " << fwd_offset << ", rev_weight: " << rev_weight << ", rev_offset: " << rev_offset; + name = facade->GetEscapedNameForNameID(phantom_nodes.target_phantom.name_id); + fwd_weight = phantom_nodes.target_phantom.forward_weight; + rev_weight = phantom_nodes.target_phantom.reverse_weight; + fwd_offset = phantom_nodes.target_phantom.forward_offset; + rev_offset = phantom_nodes.target_phantom.reverse_offset; + SimpleLogger().Write(logDEBUG) << "json target: " << name << ", location: " << phantom_nodes.target_phantom.location << ", fwd_weight: " << fwd_weight << ", fwd_offset: " << fwd_offset << ", rev_weight: " << rev_weight << ", rev_offset: " << rev_offset; + + + //TODO: replace the previous logic with this one. + + //check if first segment is non-zero + std::string road_name; + int source_duration = phantom_nodes.source_phantom.GetForwardWeightPlusOffset(); + SimpleLogger().Write(logDEBUG) << "-> source_traversed_in_reverse: " << (raw_route.source_traversed_in_reverse ? "y" : "n"); + if (!raw_route.source_traversed_in_reverse) + { + source_duration = phantom_nodes.source_phantom.GetReverseWeightPlusOffset(); + } + BOOST_ASSERT(source_duration >= 0); + road_name = facade->GetEscapedNameForNameID(phantom_nodes.source_phantom.name_id); + if (source_duration > 0) + { + SimpleLogger().Write(logDEBUG) << "adding source \"" << road_name << "\" at " << phantom_nodes.source_phantom.location << ", duration: " << source_duration; + } + else + { + SimpleLogger().Write(logDEBUG) << "ignoring source \"" << road_name << "\""; + } + + // TODO, for each unpacked segment add the leg to the description + BOOST_ASSERT( raw_route.unpacked_path_segments.size() == raw_route.segmentEndCoordinates.size() ); + + for (unsigned i = 0; i < raw_route.unpacked_path_segments.size(); ++i) + { + const std::vector & leg_path = raw_route.unpacked_path_segments[i]; + const PhantomNodes & leg_phantoms = raw_route.segmentEndCoordinates[i]; + SimpleLogger().Write(logDEBUG) << " Describing leg from " << leg_phantoms.source_phantom.location << " and " << leg_phantoms.target_phantom.location; + FixedPointCoordinate current_coordinate; + BOOST_FOREACH(const PathData & path_data, leg_path) + { + current_coordinate = facade->GetCoordinateOfNode(path_data.node); + road_name = facade->GetEscapedNameForNameID(path_data.name_id); + SimpleLogger().Write(logDEBUG) << " adding way point for \"" << road_name << "\" at " << current_coordinate << ", duration: " << path_data.durationOfSegment; + } + } + + //check if last segment is non-zero + road_name = facade->GetEscapedNameForNameID(phantom_nodes.target_phantom.name_id); + + int target_duration = phantom_nodes.target_phantom.GetForwardWeightPlusOffset(); + if (raw_route.target_traversed_in_reverse) + { + target_duration = phantom_nodes.target_phantom.GetReverseWeightPlusOffset(); + } + BOOST_ASSERT(target_duration >= 0); + + if (target_duration > 0) + { + SimpleLogger().Write(logDEBUG) << "adding target \"" << road_name << "\" at " << phantom_nodes.target_phantom.location << ", duration: " << target_duration; + } + else + { + SimpleLogger().Write(logDEBUG) << "ignoring target \"" << road_name << "\""; + } + SimpleLogger().Write(logDEBUG) << "-> target_traversed_in_reverse: " << (raw_route.target_traversed_in_reverse ? "y" : "n"); + + //END OF TODO + + description_factory.SetStartSegment(phantom_nodes.source_phantom, raw_route.source_traversed_in_reverse); reply.content.push_back("0," "\"status_message\": \"Found route between points\","); BOOST_ASSERT( raw_route.unpacked_path_segments.size() == raw_route.segmentEndCoordinates.size() ); - for( unsigned i = 0; i < raw_route.unpacked_path_segments.size(); ++i ) { + for (unsigned i = 0; i < raw_route.unpacked_path_segments.size(); ++i) + { const int added_segments = DescribeLeg( raw_route.unpacked_path_segments[i], raw_route.segmentEndCoordinates[i] @@ -143,7 +219,7 @@ public: added_segments + shortest_leg_end_indices.back() ); } - description_factory.SetEndSegment(phantom_nodes.target_phantom); + description_factory.SetEndSegment(phantom_nodes.target_phantom, raw_route.target_traversed_in_reverse); description_factory.Run(facade, config.zoom_level); reply.content.push_back("\"route_geometry\": "); @@ -195,14 +271,16 @@ public: //only one alternative route is computed at this time, so this is hardcoded - if(raw_route.lengthOfAlternativePath != INT_MAX) { - alternate_descriptionFactory.SetStartSegment(phantom_nodes.source_phantom); + + if(raw_route.lengthOfAlternativePath != INVALID_EDGE_WEIGHT) + { + alternate_descriptionFactory.SetStartSegment(phantom_nodes.source_phantom, raw_route.alt_source_traversed_in_reverse); //Get all the coordinates for the computed route BOOST_FOREACH(const PathData & path_data, raw_route.unpacked_alternative) { current = facade->GetCoordinateOfNode(path_data.node); alternate_descriptionFactory.AppendSegment(current, path_data ); } - alternate_descriptionFactory.SetEndSegment(phantom_nodes.target_phantom); + alternate_descriptionFactory.SetEndSegment(phantom_nodes.target_phantom, raw_route.alt_target_traversed_in_reverse); } alternate_descriptionFactory.Run(facade, config.zoom_level); diff --git a/RoutingAlgorithms/AlternativePathRouting.h b/RoutingAlgorithms/AlternativePathRouting.h index 589bbb393..c7571403f 100644 --- a/RoutingAlgorithms/AlternativePathRouting.h +++ b/RoutingAlgorithms/AlternativePathRouting.h @@ -316,8 +316,9 @@ public: } //Unpack shortest path and alternative, if they exist - if( INVALID_EDGE_WEIGHT != upper_bound_to_shortest_path_distance ) { - BOOST_ASSERT( !packed_shortest_path.empty() ); + if( INVALID_EDGE_WEIGHT != upper_bound_to_shortest_path_distance ) + { + BOOST_ASSERT(!packed_shortest_path.empty()); raw_route_data.unpacked_path_segments.resize(1); // SimpleLogger().Write() << "fwd offset1: " << phantom_node_pair.source_phantom.fwd_segment_position; // SimpleLogger().Write() << "fwd offset2: " << phantom_node_pair.source_phantom.rev_segment_position; @@ -332,6 +333,9 @@ public: // SimpleLogger().Write(logDEBUG) << "phantom_node_pair.target_phantom.packed_geometry_id: " << phantom_node_pair.target_phantom.packed_geometry_id; // SimpleLogger().Write(logDEBUG) << "packed_shortest_path.back(): " << packed_shortest_path.back(); + raw_route_data.source_traversed_in_reverse = (packed_shortest_path.front() != phantom_node_pair.source_phantom.forward_node_id); + raw_route_data.target_traversed_in_reverse = (packed_shortest_path.back() != phantom_node_pair.target_phantom.forward_node_id); + super::UnpackPath( // -- packed input packed_shortest_path, @@ -357,6 +361,9 @@ public: packed_alternate_path ); + raw_route_data.source_traversed_in_reverse = (packed_alternate_path.front() != phantom_node_pair.source_phantom.forward_node_id); + raw_route_data.target_traversed_in_reverse = (packed_alternate_path.back() != phantom_node_pair.target_phantom.forward_node_id); + // unpack the alternate path super::UnpackPath( packed_alternate_path, diff --git a/RoutingAlgorithms/BasicRoutingInterface.h b/RoutingAlgorithms/BasicRoutingInterface.h index 69a02e0e2..bd793d58f 100644 --- a/RoutingAlgorithms/BasicRoutingInterface.h +++ b/RoutingAlgorithms/BasicRoutingInterface.h @@ -186,6 +186,7 @@ public: } } if( SPECIAL_EDGEID == smaller_edge_id ){ + SimpleLogger().Write() << "checking reverse"; for( EdgeID edge_id = facade->BeginEdges(edge.second); edge_id < facade->EndEdges(edge.second); @@ -234,6 +235,9 @@ public: const int start_index = ( unpacked_path.empty() ? ( ( start_traversed_in_reverse ) ? id_vector.size() - phantom_node_pair.source_phantom.fwd_segment_position - 1 : phantom_node_pair.source_phantom.fwd_segment_position ) : 0 ); const int end_index = id_vector.size(); + std::string name = facade->GetEscapedNameForNameID(name_index); + SimpleLogger().Write(logDEBUG) << "compressed via segment " << name << " from [" << start_index << "," << end_index << "]"; + BOOST_ASSERT( start_index >= 0 ); BOOST_ASSERT( start_index <= end_index ); @@ -293,7 +297,7 @@ public: } } - // SimpleLogger().Write(logDEBUG) << "fetching from [" << start_index << "," << end_index << "]"; + SimpleLogger().Write(logDEBUG) << "fetching target segment from [" << start_index << "," << end_index << "]"; BOOST_ASSERT( start_index >= 0 ); for( @@ -302,10 +306,10 @@ public: ( start_index < end_index ? ++i :--i) ) { BOOST_ASSERT( i >= -1 ); - // if ( i >= 0 ) - // { - // SimpleLogger().Write(logDEBUG) << "[" << i << "]" << facade->GetCoordinateOfNode(id_vector[i]); - // } + if ( i >= 0 ) + { + SimpleLogger().Write(logDEBUG) << "target [" << i << "]" << facade->GetCoordinateOfNode(id_vector[i]); + } unpacked_path.push_back( PathData( id_vector[i], @@ -316,6 +320,11 @@ public: ); } } + BOOST_FOREACH(const PathData & path_data, unpacked_path) + { + std::string name = facade->GetEscapedNameForNameID(path_data.name_id); + SimpleLogger().Write(logDEBUG) << "{up} " << facade->GetCoordinateOfNode(path_data.node) << ", name: " << name; + } } inline void UnpackEdge( diff --git a/RoutingAlgorithms/ShortestPathRouting.h b/RoutingAlgorithms/ShortestPathRouting.h index e76493335..8372d89e3 100644 --- a/RoutingAlgorithms/ShortestPathRouting.h +++ b/RoutingAlgorithms/ShortestPathRouting.h @@ -362,17 +362,22 @@ public: ++current_leg; } - if( distance1 > distance2 ) { + if (distance1 > distance2) + { std::swap( packed_legs1, packed_legs2 ); } raw_route_data.unpacked_path_segments.resize( packed_legs1.size() ); // const int start_offset = ( packed_legs1[0].front() == phantom_nodes_vector.front().source_phantom.forward_node_id ? 1 : -1 )*phantom_nodes_vector.front().source_phantom.fwd_segment_position; - for(unsigned i = 0; i < packed_legs1.size(); ++i){ - BOOST_ASSERT( !phantom_nodes_vector.empty() ); + raw_route_data.source_traversed_in_reverse = (packed_legs1.front().front() != phantom_nodes_vector.front().source_phantom.forward_node_id); + raw_route_data.target_traversed_in_reverse = (packed_legs1.back().back() != phantom_nodes_vector.back().target_phantom.forward_node_id); + + for (unsigned i = 0; i < packed_legs1.size(); ++i) + { + BOOST_ASSERT(!phantom_nodes_vector.empty()); // const bool at_beginning = (packed_legs1[i] == packed_legs1.front()); // const bool at_end = (packed_legs1[i] == packed_legs1.back()); - BOOST_ASSERT(packed_legs1.size() == raw_route_data.unpacked_path_segments.size() ); + BOOST_ASSERT(packed_legs1.size() == raw_route_data.unpacked_path_segments.size()); PhantomNodes unpack_phantom_node_pair = phantom_nodes_vector[i]; // if (!at_beginning)