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

adjust testscases for collapse of use lane

Browse Source
This commit is contained in:
Moritz Kobitzsch
2016-07-22 09:08:40 +02:00
parent 86fd04e556
commit a551286a8f
25 changed files with 225 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/extractor/guidance/intersection_generator.cpp
+1 -1
View File
@@ -1,5 +1,5 @@
#include "extractor/guidance/constants.hpp"
#include "extractor/guidance/intersection_generator.hpp"
#include "extractor/guidance/constants.hpp"
#include "extractor/guidance/toolkit.hpp"
#include <algorithm>
src/extractor/guidance/turn_discovery.cpp
+1 -1
View File
@@ -1,5 +1,5 @@
#include "extractor/guidance/constants.hpp"
#include "extractor/guidance/turn_discovery.hpp"
#include "extractor/guidance/constants.hpp"
namespace osrm
{
src/extractor/guidance/turn_lane_augmentation.cpp
+5 -14
View File
@@ -283,27 +283,18 @@ LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
// we have to reduce it, assigning it to neighboring turns
else if (connection_count < lane_data.size())
{
if( connection_count+1 < lane_data.size() ){
std::cout << "[error] failed assignment" << std::endl;
util::guidance::print(lane_data);
std::cout << "Intersection:\n";
for( auto road : intersection )
std::cout << "\t" << toString(road) << std::endl;
}
// a pgerequisite is simple turns. Larger differences should not end up here
// an additional line at the side is only reasonable if it is targeting public
// service vehicles. Otherwise, we should not have it
//
// TODO(mokob): #2730 have a look please
// BOOST_ASSERT(connection_count + 1 == lane_data.size());
//
if (connection_count + 1 != lane_data.size())
if (connection_count + 1 == lane_data.size())
{
// skip broken intersections
lane_data = mergeNoneTag(none_index, std::move(lane_data));
}
else
{
lane_data = mergeNoneTag(none_index, std::move(lane_data));
// This represents a currently unhandled case. It should not even get here, but to be
// sure we return nevertheless.
return lane_data;
}
}
// we have to rename and possibly augment existing ones. The pure count remains the
src/extractor/guidance/turn_lane_data.cpp
-21
View File
@@ -154,27 +154,6 @@ bool hasTag(const TurnLaneType::Mask tag, const LaneDataVector &data)
return findTag(tag, data) != data.cend();
}
bool isSubsetOf(const LaneDataVector &subset_candidate, const LaneDataVector &superset_candidate)
{
auto location = superset_candidate.begin();
for (const auto entry : subset_candidate)
{
location = std::find_if(
location, superset_candidate.end(), [entry](const TurnLaneData &lane_data) {
return lane_data.tag == entry.tag;
});
if (location == superset_candidate.end())
return false;
// compare the number of lanes TODO this might have be to be revisited for situations where
// a sliproad widens into multiple lanes
if ((location->to - location->from) != (entry.to - entry.from))
return false;
}
return true;
}
} // namespace lanes
} // namespace guidance
} // namespace extractor
src/extractor/guidance/turn_lane_handler.cpp
+19 -47
View File
@@ -1,9 +1,7 @@
#include "util/debug.hpp"
#include "extractor/guidance/turn_lane_handler.hpp"
#include "extractor/guidance/constants.hpp"
#include "extractor/guidance/turn_discovery.hpp"
#include "extractor/guidance/turn_lane_augmentation.hpp"
#include "extractor/guidance/turn_lane_handler.hpp"
#include "extractor/guidance/turn_lane_matcher.hpp"
#include "util/simple_logger.hpp"
#include "util/typedefs.hpp"
@@ -33,8 +31,6 @@ std::size_t getNumberOfTurns(const Intersection &intersection)
}
} // namespace
const constexpr char *TurnLaneHandler::scenario_names[TurnLaneScenario::NUM_SCENARIOS];
TurnLaneHandler::TurnLaneHandler(const util::NodeBasedDynamicGraph &node_based_graph,
std::vector<std::uint32_t> &turn_lane_offsets,
std::vector<TurnLaneType::Mask> &turn_lane_masks,
@@ -46,18 +42,12 @@ TurnLaneHandler::TurnLaneHandler(const util::NodeBasedDynamicGraph &node_based_g
turn_lane_masks(turn_lane_masks), lane_description_map(lane_description_map),
node_info_list(node_info_list), turn_analysis(turn_analysis), id_map(id_map)
{
count_handled = new unsigned;
count_called = new unsigned;
*count_handled = *count_called = 0;
}
TurnLaneHandler::~TurnLaneHandler()
{
std::cout << "Handled: " << *count_handled << " of " << *count_called
<< " lanes: " << (double)(*count_handled * 100) / (*count_called) << " %."
<< std::endl;
delete count_called;
delete count_handled;
std::cout << "Handled: " << count_handled << " of " << count_called
<< " lanes: " << (double)(count_handled * 100) / (count_called) << " %." << std::endl;
}
/*
@@ -107,8 +97,8 @@ TurnLaneHandler::assignTurnLanes(const NodeID at, const EdgeID via_edge, Interse
previous_lane_data,
previous_description_id);
if (scenario != TurnLaneHandler::NONE)
(*count_called)++;
if (scenario != TurnLaneScenario::NONE)
count_called++;
switch (scenario)
{
@@ -140,44 +130,26 @@ TurnLaneHandler::assignTurnLanes(const NodeID at, const EdgeID via_edge, Interse
// case TurnLaneScenario::UNKNOWN:
// case TurnLaneScenario::NONE:
// case TurnLaneScenario::INVALID:
{
/*
static int print_count = 0;
if (TurnLaneScenario::NONE != scenario && print_count++ < 10)
{
std::cout << "[Unhandled] " << (int)lane_description_id << " -- "
<< (int)previous_description_id << "\n"
<< std::endl;
util::guidance::printTurnAssignmentData(
at, lane_data, intersection, node_info_list);
if (previous_node != SPECIAL_NODEID)
util::guidance::printTurnAssignmentData(
previous_node, previous_lane_data, previous_intersection, node_info_list);
}
*/
}
return intersection;
}
}
// Find out which scenario we have to handle
TurnLaneHandler::TurnLaneScenario
TurnLaneHandler::deduceScenario(const NodeID at,
const EdgeID via_edge,
const Intersection &intersection,
// Output Variables
LaneDescriptionID &lane_description_id,
LaneDataVector &lane_data,
NodeID &previous_node,
EdgeID &previous_via_edge,
Intersection &previous_intersection,
LaneDataVector &previous_lane_data,
LaneDescriptionID &previous_description_id)
TurnLaneScenario TurnLaneHandler::deduceScenario(const NodeID at,
const EdgeID via_edge,
const Intersection &intersection,
// Output Variables
LaneDescriptionID &lane_description_id,
LaneDataVector &lane_data,
NodeID &previous_node,
EdgeID &previous_via_edge,
Intersection &previous_intersection,
LaneDataVector &previous_lane_data,
LaneDescriptionID &previous_description_id)
{
// if only a uturn exists, there is nothing we can do
if (intersection.size() == 1)
return TurnLaneHandler::NONE;
return TurnLaneScenario::NONE;
extractLaneData(via_edge, lane_description_id, lane_data);
@@ -199,7 +171,7 @@ TurnLaneHandler::deduceScenario(const NodeID at,
angularDeviation(intersection[1].turn.angle, STRAIGHT_ANGLE) < FUZZY_ANGLE_DIFFERENCE));
if (is_going_straight_and_turns_continue)
return TurnLaneHandler::NONE;
return TurnLaneScenario::NONE;
// if we see an invalid conversion, we stop immediately
if (lane_description_id != INVALID_LANE_DESCRIPTIONID && lane_data.empty())
@@ -694,7 +666,7 @@ Intersection TurnLaneHandler::simpleMatchTuplesToTurns(Intersection intersection
!hasTag(TurnLaneType::none | TurnLaneType::merge_to_left | TurnLaneType::merge_to_right,
lane_data));
(*count_handled)++;
count_handled++;
return triviallyMatchLanesToTurns(
std::move(intersection), lane_data, node_based_graph, lane_description_id, id_map);
src/extractor/guidance/turn_lane_matcher.cpp
+19 -19
View File
@@ -1,5 +1,5 @@
#include "extractor/guidance/toolkit.hpp"
#include "extractor/guidance/turn_lane_matcher.hpp"
#include "extractor/guidance/toolkit.hpp"
#include "util/guidance/toolkit.hpp"
#include <boost/assert.hpp>
@@ -102,11 +102,11 @@ bool isValidMatch(const TurnLaneType::Mask tag, const TurnInstruction instructio
return false;
}
double getMatchingQuality( const TurnLaneType::Mask tag, const ConnectedRoad &road)
double getMatchingQuality(const TurnLaneType::Mask tag, const ConnectedRoad &road)
{
const constexpr double idealized_turn_angles[] = {0, 35, 90, 135, 180, 225, 270, 315};
const auto idealized_angle = idealized_turn_angles[getMatchingModifier(tag)];
return angularDeviation(idealized_angle,road.turn.angle);
return angularDeviation(idealized_angle, road.turn.angle);
}
// Every tag is somewhat idealized in form of the expected angle. A through lane should go straight
@@ -116,21 +116,21 @@ double getMatchingQuality( const TurnLaneType::Mask tag, const ConnectedRoad &ro
typename Intersection::const_iterator findBestMatch(const TurnLaneType::Mask tag,
const Intersection &intersection)
{
return std::min_element(
intersection.begin(),
intersection.end(),
[tag](const ConnectedRoad &lhs, const ConnectedRoad &rhs) {
// prefer valid matches
if (isValidMatch(tag, lhs.turn.instruction) != isValidMatch(tag, rhs.turn.instruction))
return isValidMatch(tag, lhs.turn.instruction);
return std::min_element(intersection.begin(),
intersection.end(),
[tag](const ConnectedRoad &lhs, const ConnectedRoad &rhs) {
// prefer valid matches
if (isValidMatch(tag, lhs.turn.instruction) !=
isValidMatch(tag, rhs.turn.instruction))
return isValidMatch(tag, lhs.turn.instruction);
// if the entry allowed flags don't match, we select the one with
// entry allowed set to true
if (lhs.entry_allowed != rhs.entry_allowed)
return lhs.entry_allowed;
// if the entry allowed flags don't match, we select the one with
// entry allowed set to true
if (lhs.entry_allowed != rhs.entry_allowed)
return lhs.entry_allowed;
return getMatchingQuality(tag,lhs) < getMatchingQuality(tag,rhs);
});
return getMatchingQuality(tag, lhs) < getMatchingQuality(tag, rhs);
});
}
// Reverse is a special case, because it requires access to the leftmost tag. It has its own
@@ -138,8 +138,8 @@ typename Intersection::const_iterator findBestMatch(const TurnLaneType::Mask tag
// by default in OSRM. Therefor we cannot check whether a turn is allowed, since it could be
// possible that it is forbidden. In addition, the best u-turn angle does not necessarily represent
// the u-turn, since it could be a sharp-left turn instead on a road with a middle island.
typename Intersection::const_iterator
findBestMatchForReverse(const TurnLaneType::Mask neighbor_tag, const Intersection &intersection)
typename Intersection::const_iterator findBestMatchForReverse(const TurnLaneType::Mask neighbor_tag,
const Intersection &intersection)
{
const auto neighbor_itr = findBestMatch(neighbor_tag, intersection);
if (neighbor_itr + 1 == intersection.cend())
@@ -159,7 +159,7 @@ findBestMatchForReverse(const TurnLaneType::Mask neighbor_tag, const Intersectio
if (lhs.entry_allowed != rhs.entry_allowed)
return lhs.entry_allowed;
return getMatchingQuality(tag,lhs) < getMatchingQuality(tag,rhs);
return getMatchingQuality(tag, lhs) < getMatchingQuality(tag, rhs);
});
}