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

Move debug printer code to own header

Browse Source
This commit is contained in:
Patrick Niklaus 2018-02-02 15:50:33 +00:00 committed by Patrick Niklaus
parent 83d7a57b73
commit e7bb612050
15 changed files with 207 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
include/engine/phantom_node.hpp
View File

@ -25,21 +25,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef PHANTOM_NODES_H
#define PHANTOM_NODES_H
#ifndef OSRM_ENGINE_PHANTOM_NODES_H
#define OSRM_ENGINE_PHANTOM_NODES_H
#include "extractor/travel_mode.hpp"
#include "util/typedefs.hpp"
#include "util/typedefs.hpp"
#include "util/bearing.hpp"
#include "util/coordinate.hpp"
#include <boost/assert.hpp>
#include <iostream>
#include <utility>
#include <vector>
namespace osrm
{
namespace engine
@ -200,30 +196,6 @@ struct PhantomNodes
PhantomNode target_phantom;
};
inline std::ostream &operator<<(std::ostream &out, const PhantomNodes &pn)
{
out << "source_coord: " << pn.source_phantom.location << "\n";
out << "target_coord: " << pn.target_phantom.location << std::endl;
return out;
}
inline std::ostream &operator<<(std::ostream &out, const PhantomNode &pn)
{
out << "node1: " << pn.forward_segment_id.id << ", "
<< "node2: " << pn.reverse_segment_id.id << ", "
<< "fwd-w: " << pn.forward_weight << ", "
<< "rev-w: " << pn.reverse_weight << ", "
<< "fwd-o: " << pn.forward_weight_offset << ", "
<< "rev-o: " << pn.reverse_weight_offset << ", "
<< "fwd-d: " << pn.forward_duration << ", "
<< "rev-d: " << pn.reverse_duration << ", "
<< "fwd-do: " << pn.forward_duration_offset << ", "
<< "rev-do: " << pn.reverse_duration_offset << ", "
<< "comp: " << pn.component.is_tiny << " / " << pn.component.id << ", "
<< "pos: " << pn.fwd_segment_position << ", "
<< "loc: " << pn.location;
return out;
}
}
}

4
include/extractor/intersection/intersection_view.hpp
View File

@ -75,10 +75,6 @@ struct IntersectionViewData : IntersectionShapeData
bool CompareByAngle(const IntersectionViewData &other) const;
};
// small helper function to print the content of a connected road
std::string toString(const IntersectionShapeData &shape);
std::string toString(const IntersectionViewData &view);
// Intersections are sorted roads: [0] being the UTurn road, then from sharp right to sharp left.
// common operations shared amongst all intersection types
template <typename Self> struct EnableShapeOps

55
include/extractor/turn_lane_types.hpp
View File

@ -1,20 +1,18 @@
#ifndef OSRM_GUIDANCE_TURN_LANE_TYPES_HPP_
#define OSRM_GUIDANCE_TURN_LANE_TYPES_HPP_
#include "util/concurrent_id_map.hpp"
#include "util/integer_range.hpp"
#include "util/typedefs.hpp"
#include <boost/functional/hash.hpp>
#include <bitset>
#include <cstddef>
#include <cstdint>
#include <numeric> //partial_sum
#include <string>
#include <unordered_map>
#include <vector>
#include <boost/functional/hash.hpp>
#include "util/concurrent_id_map.hpp"
#include "util/json_container.hpp"
#include "util/typedefs.hpp"
namespace osrm
{
namespace extractor
@ -22,11 +20,11 @@ namespace extractor
namespace TurnLaneType
{
namespace detail
{
const constexpr std::size_t num_supported_lane_types = 11;
const constexpr std::size_t NUM_TYPES = 11;
const constexpr char *translations[detail::num_supported_lane_types] = {"none",
inline auto laneTypeToName(const std::size_t type_id)
{
const static char *name[NUM_TYPES] = {"none",
"straight",
"sharp left",
"left",
@ -37,8 +35,8 @@ const constexpr char *translations[detail::num_supported_lane_types] = {"none",
"uturn",
"merge to left",
"merge to right"};
} // namespace detail
return name[type_id];
}
typedef std::uint16_t Mask;
const constexpr Mask empty = 0u;
@ -54,30 +52,6 @@ const constexpr Mask uturn = 1u << 8u;
const constexpr Mask merge_to_left = 1u << 9u;
const constexpr Mask merge_to_right = 1u << 10u;
inline std::string toString(const Mask lane_type)
{
if (lane_type == 0)
return "none";
std::bitset<8 * sizeof(Mask)> mask(lane_type);
std::string result = "";
for (std::size_t lane_id_nr = 0; lane_id_nr < detail::num_supported_lane_types; ++lane_id_nr)
if (mask[lane_id_nr])
result += (result.empty() ? detail::translations[lane_id_nr]
: (std::string(";") + detail::translations[lane_id_nr]));
return result;
}
inline util::json::Array toJsonArray(const Mask lane_type)
{
util::json::Array result;
std::bitset<8 * sizeof(Mask)> mask(lane_type);
for (std::size_t lane_id_nr = 0; lane_id_nr < detail::num_supported_lane_types; ++lane_id_nr)
if (mask[lane_id_nr])
result.values.push_back(detail::translations[lane_id_nr]);
return result;
}
} // TurnLaneType
typedef std::vector<TurnLaneType::Mask> TurnLaneDescription;
@ -93,8 +67,9 @@ struct TurnLaneDescription_hash
}
};
typedef util::ConcurrentIDMap<TurnLaneDescription, LaneDescriptionID, TurnLaneDescription_hash>
LaneDescriptionMap;
using LaneDescriptionMap = util::ConcurrentIDMap<TurnLaneDescription,
LaneDescriptionID,
TurnLaneDescription_hash>;
using TurnLanesIndexedArray =
std::tuple<std::vector<std::uint32_t>, std::vector<TurnLaneType::Mask>>;

8
include/util/coordinate.hpp
View File

@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef COORDINATE_HPP_
#define COORDINATE_HPP_
#ifndef OSRM_UTIL_COORDINATE_HPP_
#define OSRM_UTIL_COORDINATE_HPP_
#include "util/alias.hpp"
@ -216,7 +216,6 @@ struct Coordinate
bool IsValid() const;
friend bool operator==(const Coordinate lhs, const Coordinate rhs);
friend bool operator!=(const Coordinate lhs, const Coordinate rhs);
friend std::ostream &operator<<(std::ostream &out, const Coordinate coordinate);
};
/**
@ -257,13 +256,10 @@ struct FloatCoordinate
bool IsValid() const;
friend bool operator==(const FloatCoordinate lhs, const FloatCoordinate rhs);
friend bool operator!=(const FloatCoordinate lhs, const FloatCoordinate rhs);
friend std::ostream &operator<<(std::ostream &out, const FloatCoordinate coordinate);
};
bool operator==(const Coordinate lhs, const Coordinate rhs);
bool operator==(const FloatCoordinate lhs, const FloatCoordinate rhs);
std::ostream &operator<<(std::ostream &out, const Coordinate coordinate);
std::ostream &operator<<(std::ostream &out, const FloatCoordinate coordinate);
inline Coordinate::Coordinate(const FloatCoordinate &other)
: Coordinate(toFixed(other.lon), toFixed(other.lat))

186
include/util/debug.hpp
View File

@ -1,5 +1,5 @@
#ifndef OSRM_ENGINE_GUIDANCE_DEBUG_HPP_
#define OSRM_ENGINE_GUIDANCE_DEBUG_HPP_
#ifndef OSRM_UTIL_DEBUG_HPP_
#define OSRM_UTIL_DEBUG_HPP_
#include "extractor/node_data_container.hpp"
#include "extractor/query_node.hpp"
@ -19,16 +19,23 @@ namespace osrm
{
namespace util
{
inline std::ostream &operator<<(std::ostream &out, const Coordinate &coordinate)
{
out << std::setprecision(12) << "{" << toFloating(coordinate.lon) << ", "
<< toFloating(coordinate.lon) << "}";
return out;
}
}
namespace engine
{
namespace guidance
{
inline void print(const engine::guidance::RouteStep &step)
inline std::ostream &operator<<(std::ostream &out, const RouteStep &step)
{
std::cout << static_cast<int>(step.maneuver.instruction.type) << " "
out << "RouteStep {" << static_cast<int>(step.maneuver.instruction.type) << " "
<< static_cast<int>(step.maneuver.instruction.direction_modifier) << " "
<< static_cast<int>(step.maneuver.waypoint_type) << " " << step.maneuver.location
<< " "
<< static_cast<int>(step.maneuver.waypoint_type) << " " << step.maneuver.location << " "
<< " Duration: " << step.duration << " Distance: " << step.distance
<< " Geometry: " << step.geometry_begin << " " << step.geometry_end
<< " Exit: " << step.maneuver.exit << " Mode: " << (int)step.mode
@ -36,83 +43,150 @@ inline void print(const engine::guidance::RouteStep &step)
for (const auto &intersection : step.intersections)
{
std::cout << "(Lanes: " << static_cast<int>(intersection.lanes.lanes_in_turn) << " "
out << "(Lanes: " << static_cast<int>(intersection.lanes.lanes_in_turn) << " "
<< static_cast<int>(intersection.lanes.first_lane_from_the_right) << " ["
<< intersection.in << "," << intersection.out << "]"
<< " bearings:";
for (auto bearing : intersection.bearings)
std::cout << " " << bearing;
std::cout << ", entry: ";
out << " " << bearing;
out << ", entry: ";
for (auto entry : intersection.entry)
std::cout << " " << (entry ? "true" : "false");
std::cout << ")";
out << " " << (entry ? "true" : "false");
out << ")";
}
std::cout << "] name[" << step.name_id << "]: " << step.name << " Ref: " << step.ref
out << "] name[" << step.name_id << "]: " << step.name << " Ref: " << step.ref
<< " Pronunciation: " << step.pronunciation << "Destination: " << step.destinations
<< "Exits: " << step.exits;
<< "Exits: " << step.exits << "}";
return out;
}
}
}
inline void print(const std::vector<engine::guidance::RouteStep> &steps)
namespace guidance
{
std::cout << "Path\n";
inline std::ostream &operator<<(std::ostream &out, const ConnectedRoad &road)
{
out << "ConnectedRoad {" << road.eid << " allows entry: " << road.entry_allowed
<< " angle: " << road.angle << " bearing: " << road.bearing
<< " instruction: " << static_cast<std::int32_t>(road.instruction.type) << " "
<< static_cast<std::int32_t>(road.instruction.direction_modifier) << " "
<< static_cast<std::int32_t>(road.lane_data_id) << "}";
return out;
}
}
namespace extractor
{
namespace intersection
{
inline std::ostream &operator<<(std::ostream &out, const IntersectionShapeData &shape)
{
out << "IntersectionShapeData { " << shape.eid << " bearing: " << shape.bearing << "}";
return out;
}
inline std::ostream &operator<<(std::ostream &out, const IntersectionViewData &view)
{
out << "IntersectionViewData {" << view.eid << " allows entry: " << view.entry_allowed
<< " angle: " << view.angle << " bearing: " << view.bearing << "}";
return out;
}
}
namespace TurnLaneType
{
inline std::ostream &operator<<(std::ostream &out, const Mask lane_type)
{
if (lane_type == 0)
{
out << "none";
return out;
}
bool first = true;
std::bitset<8 * sizeof(Mask)> mask(lane_type);
for (auto index : util::irange<std::size_t>(0, NUM_TYPES))
{
if (!first)
{
out << ";";
}
if (mask[index])
{
out << laneTypeToName(index);
first = false;
}
}
return out;
}
}
}
}
namespace std
{
inline std::ostream &operator<<(std::ostream &out,
const std::vector<osrm::engine::guidance::RouteStep> &steps)
{
out << "{";
int segment = 0;
for (const auto &step : steps)
{
std::cout << "\t[" << segment++ << "]: ";
print(step);
std::cout << std::endl;
if (segment > 0)
out << ", ";
out << step;
segment++;
}
out << "}";
return out;
}
}
inline void print(const osrm::guidance::Intersection &intersection)
namespace osrm
{
std::cout << " Intersection:\n";
for (const auto &road : intersection)
std::cout << "\t" << toString(road) << "\n";
std::cout << std::flush;
}
inline void print(const NodeBasedDynamicGraph &node_based_graph,
const osrm::guidance::Intersection &intersection)
namespace guidance
{
std::cout << " Intersection:\n";
inline std::ostream &operator<<(std::ostream &out, const Intersection &intersection)
{
out << "Intersection {";
int segment = 0;
for (const auto &road : intersection)
{
std::cout << "\t" << toString(road) << "\n";
std::cout << "\t\t"
<< node_based_graph.GetEdgeData(road.eid).flags.road_classification.ToString()
<< "\n";
if (segment > 0)
out << ", ";
out << road;
segment++;
}
std::cout << std::flush;
out << "}";
return out;
}
inline void print(const osrm::guidance::lanes::LaneDataVector &turn_lane_data)
namespace lanes
{
std::cout << " Tags:\n";
inline std::ostream &operator<<(std::ostream &out, const LaneDataVector &turn_lane_data)
{
out << " LaneDataVector {";
int segment = 0;
for (auto entry : turn_lane_data)
std::cout << "\t" << entry.tag << "(" << extractor::TurnLaneType::toString(entry.tag)
<< ") from: " << static_cast<int>(entry.from)
<< " to: " << static_cast<int>(entry.to) << "\n";
std::cout << std::flush;
}
inline void printTurnAssignmentData(const NodeID at,
const osrm::guidance::lanes::LaneDataVector &turn_lane_data,
const osrm::guidance::Intersection &intersection,
const std::vector<extractor::QueryNode> &node_info_list)
{
std::cout << "[Turn Assignment Progress]\nLocation:";
auto coordinate = node_info_list[at];
std::cout << std::setprecision(12) << toFloating(coordinate.lat) << " "
<< toFloating(coordinate.lon) << "\n";
if (segment > 0)
out << ", ";
out << entry.tag << "(" << entry.tag << ") from: " << static_cast<int>(entry.from)
<< " to: " << static_cast<int>(entry.to);
segment++;
}
out << "}";
print(intersection);
// flushes as well
print(turn_lane_data);
return out;
}
}
} // namespace guidance
} // namespace util
} // namespace osrm
}
}
#endif /*OSRM_ENGINE_GUIDANCE_DEBUG_HPP_*/

16
src/engine/api/json_factory.cpp
View File

@ -46,6 +46,20 @@ inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection
return intersection.lanes.lanes_in_turn > 0;
}
inline util::json::Array toJSON(const extractor::TurnLaneType::Mask lane_type)
{
util::json::Array result;
std::bitset<8 * sizeof(extractor::TurnLaneType::Mask)> mask(lane_type);
for (auto index : util::irange<std::size_t>(0, extractor::TurnLaneType::NUM_TYPES))
{
if (mask[index])
{
result.values.push_back(extractor::TurnLaneType::laneTypeToName(index));
}
}
return result;
}
util::json::Array lanesFromIntersection(const guidance::IntermediateIntersection &intersection)
{
BOOST_ASSERT(intersection.lanes.lanes_in_turn >= 1);
@ -56,7 +70,7 @@ util::json::Array lanesFromIntersection(const guidance::IntermediateIntersection
{
--lane_id;
util::json::Object lane;
lane.values["indications"] = extractor::TurnLaneType::toJsonArray(lane_desc);
lane.values["indications"] = toJSON(lane_desc);
if (lane_id >= intersection.lanes.first_lane_from_the_right &&
lane_id <
intersection.lanes.first_lane_from_the_right + intersection.lanes.lanes_in_turn)

7
src/guidance/roundabout_handler.cpp
View File

@ -6,6 +6,7 @@
#include "util/coordinate_calculation.hpp"
#include "util/guidance/name_announcements.hpp"
#include "util/log.hpp"
#include "util/to_osm_link.hpp"
#include <algorithm>
#include <cmath>
@ -177,7 +178,7 @@ bool RoundaboutHandler::qualifiesAsRoundaboutIntersection(
// but is at least not random.
if (src_coordinate == next_coordinate)
{
util::Log(logDEBUG) << "Zero length segment at " << next_coordinate
util::Log(logDEBUG) << "Zero length segment at " << toOSMLink(next_coordinate)
<< " could cause invalid roundabout exit bearings";
BOOST_ASSERT(std::abs(result.back()) <= 0.1);
}
@ -210,7 +211,9 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
std::unordered_set<unsigned> connected_names;
const auto getNextOnRoundabout = [this, &roundabout_name_ids, &connected_names](
const NodeID node, const bool roundabout, const bool circular) {
const NodeID node,
const bool roundabout,
const bool circular) {
BOOST_ASSERT(roundabout != circular);
EdgeID continue_edge = SPECIAL_EDGEID;
for (const auto edge_id : node_based_graph.GetAdjacentEdgeRange(node))

10
src/guidance/turn_classification.cpp
View File

@ -1,5 +1,7 @@
#include "guidance/turn_classification.hpp"
#include "util/to_osm_link.hpp"
#include <algorithm>
#include <cstddef>
#include <cstdint>
@ -56,8 +58,10 @@ classifyIntersection(Intersection intersection, const osrm::util::Coordinate &lo
if (road.entry_allowed)
{
if (!entry_class.activate(number))
{
util::Log(logWARNING) << "Road " << number << " was not activated at "
<< location;
<< util::toOSMLink(location);
}
}
auto discrete_bearing_class =
@ -74,8 +78,10 @@ classifyIntersection(Intersection intersection, const osrm::util::Coordinate &lo
if (road.entry_allowed)
{
if (!entry_class.activate(number))
{
util::Log(logWARNING) << "Road " << number << " was not activated at "
<< location;
<< util::toOSMLink(location);
}
}
bearing_class.add(std::round(road.bearing));
++number;

2
src/guidance/turn_lane_data.cpp
View File

@ -76,7 +76,7 @@ LaneDataVector laneDataFromDescription(TurnLaneDescription turn_lane_description
return (test_mask & full_mask) == test_mask;
};
for (std::size_t shift = 0; shift < TurnLaneType::detail::num_supported_lane_types; ++shift)
for (const auto shift : util::irange<std::size_t>(0, TurnLaneType::NUM_TYPES))
{
TurnLaneType::Mask mask = 1 << shift;
if (isSet(mask))

11
src/util/coordinate.cpp
View File

@ -43,16 +43,5 @@ bool operator==(const FloatCoordinate lhs, const FloatCoordinate rhs)
bool operator!=(const Coordinate lhs, const Coordinate rhs) { return !(lhs == rhs); }
bool operator!=(const FloatCoordinate lhs, const FloatCoordinate rhs) { return !(lhs == rhs); }
std::ostream &operator<<(std::ostream &out, const Coordinate coordinate)
{
out << std::setprecision(12) << "(lon:" << toFloating(coordinate.lon)
<< ", lat:" << toFloating(coordinate.lat) << ")";
return out;
}
std::ostream &operator<<(std::ostream &out, const FloatCoordinate coordinate)
{
out << std::setprecision(12) << "(lon:" << coordinate.lon << ", lat:" << coordinate.lat << ")";
return out;
}
}
}

1
unit_tests/engine/douglas_peucker.cpp
View File

@ -1,5 +1,6 @@
#include "engine/douglas_peucker.hpp"
#include "util/coordinate_calculation.hpp"
#include "util/debug.hpp"
#include <boost/test/test_case_template.hpp>
#include <boost/test/unit_test.hpp>

2
unit_tests/partitioner/bisection_graph.cpp
View File

@ -1,6 +1,8 @@
#include "partitioner/bisection_graph.hpp"
#include "partitioner/graph_generator.hpp"
#include "util/debug.hpp"
#include <algorithm>
#include <vector>

2
unit_tests/partitioner/bisection_graph_view.cpp
View File

@ -2,6 +2,8 @@
#include "partitioner/graph_generator.hpp"
#include "partitioner/recursive_bisection_state.hpp"
#include "util/debug.hpp"
#include <algorithm>
#include <climits>
#include <vector>

2
unit_tests/server/parameters_parser.cpp
View File

@ -10,6 +10,8 @@
#include "engine/api/tile_parameters.hpp"
#include "engine/api/trip_parameters.hpp"
#include "util/debug.hpp"
#include <boost/optional/optional_io.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>

1
unit_tests/util/coordinate_calculation.cpp
View File

@ -4,6 +4,7 @@
#include "util/bearing.hpp"
#include "util/coordinate_calculation.hpp"
#include "util/web_mercator.hpp"
#include "util/debug.hpp"
#include <osrm/coordinate.hpp>