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

Updated guidance/

Browse Source
This commit is contained in:
Mugr Rex 2023-04-04 14:32:43 +02:00
parent 97d3fcbbb0
commit 850a3a7f74
13 changed files with 50 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/guidance/intersection_handler.hpp
View File

@ -17,8 +17,7 @@
#include <cstddef>
#include <utility>
#include <vector>
#include <boost/optional.hpp>
#include <optional>
namespace osrm::guidance
{
@ -129,7 +128,7 @@ class IntersectionHandler
// ^ via
//
// For this scenario returns intersection at `b` and `b`.
boost::optional<IntersectionHandler::IntersectionViewAndNode>
std::optional<IntersectionHandler::IntersectionViewAndNode>
getNextIntersection(const NodeID at, const EdgeID via) const;
bool isSameName(const EdgeID source_edge_id, const EdgeID target_edge_id) const;

5
include/guidance/sliproad_handler.hpp
View File

@ -10,8 +10,7 @@
#include "util/node_based_graph.hpp"
#include <vector>
#include <boost/optional.hpp>
#include <optional>
namespace osrm::guidance
{
@ -43,7 +42,7 @@ class SliproadHandler final : public IntersectionHandler
Intersection intersection) const override final;
private:
boost::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
std::optional<std::size_t> getObviousIndexWithSliproads(const EdgeID from,
const Intersection &intersection,
const NodeID at) const;

7
include/guidance/turn_handler.hpp
View File

@ -11,8 +11,7 @@
#include "util/attributes.hpp"
#include "util/node_based_graph.hpp"
#include <boost/optional.hpp>
#include <optional>
#include <cstddef>
#include <utility>
#include <vector>
@ -72,7 +71,7 @@ class TurnHandler final : public IntersectionHandler
bool hasObvious(const EdgeID &via_edge, const Fork &fork) const;
boost::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;
std::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;
bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const;
@ -96,7 +95,7 @@ class TurnHandler final : public IntersectionHandler
handleDistinctConflict(const EdgeID via_edge, ConnectedRoad &left, ConnectedRoad &right) const;
// Classification
boost::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
std::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
OSRM_ATTR_WARN_UNUSED
Intersection assignLeftTurns(const EdgeID via_edge,

4
include/util/coordinate_calculation.hpp
View File

@ -4,8 +4,8 @@
#include "util/coordinate.hpp"
#include <boost/math/constants/constants.hpp>
#include <boost/optional.hpp>
#include <optional>
#include <algorithm>
#include <cmath>
#include <numeric>
@ -102,7 +102,7 @@ double bearing(const Coordinate first_coordinate, const Coordinate second_coordi
double computeAngle(const Coordinate first, const Coordinate second, const Coordinate third);
// find the center of a circle through three coordinates
boost::optional<Coordinate> circleCenter(const Coordinate first_coordinate,
std::optional<Coordinate> circleCenter(const Coordinate first_coordinate,
const Coordinate second_coordinate,
const Coordinate third_coordinate);

11
include/util/geojson_debug_policies.hpp
View File

@ -2,6 +2,7 @@
#define OSRM_GEOJSON_DEBUG_POLICIES
#include <vector>
#include <optional>
#include "extractor/query_node.hpp"
#include "util/coordinate.hpp"
@ -9,8 +10,6 @@
#include "util/node_based_graph.hpp"
#include "util/typedefs.hpp"
#include <boost/optional.hpp>
namespace osrm::util
{
@ -20,7 +19,7 @@ struct NodeIdVectorToLineString
// converts a vector of node ids into a linestring geojson feature
util::json::Object operator()(const std::vector<NodeID> &node_ids,
const boost::optional<json::Object> &properties = {}) const;
const std::optional<json::Object> &properties = {}) const;
const std::vector<util::Coordinate> &node_coordinates;
};
@ -29,7 +28,7 @@ struct CoordinateVectorToLineString
{
// converts a vector of node ids into a linestring geojson feature
util::json::Object operator()(const std::vector<util::Coordinate> &coordinates,
const boost::optional<json::Object> &properties = {}) const;
const std::optional<json::Object> &properties = {}) const;
};
struct NodeIdVectorToMultiPoint
@ -38,7 +37,7 @@ struct NodeIdVectorToMultiPoint
// converts a vector of node ids into a linestring geojson feature
util::json::Object operator()(const std::vector<NodeID> &node_ids,
const boost::optional<json::Object> &properties = {}) const;
const std::optional<json::Object> &properties = {}) const;
const std::vector<util::Coordinate> &node_coordinates;
};
@ -47,7 +46,7 @@ struct CoordinateVectorToMultiPoint
{
// converts a vector of node ids into a linestring geojson feature
util::json::Object operator()(const std::vector<util::Coordinate> &coordinates,
const boost::optional<json::Object> &properties = {}) const;
const std::optional<json::Object> &properties = {}) const;
};
} // namespace osrm::util

5
include/util/geojson_debug_policy_toolkit.hpp
View File

@ -5,11 +5,10 @@
#include "util/coordinate.hpp"
#include "util/json_container.hpp"
#include <optional>
#include <algorithm>
#include <iterator>
#include <boost/optional.hpp>
namespace osrm::util
{
@ -84,7 +83,7 @@ struct NodeIdToCoordinate
inline util::json::Object makeFeature(std::string type,
util::json::Array coordinates,
const boost::optional<util::json::Object> &properties = {})
const std::optional<util::json::Object> &properties = {})
{
util::json::Object result;
result.values["type"] = "Feature";

4
include/util/timezones.hpp
View File

@ -6,10 +6,10 @@
#include <boost/filesystem/path.hpp>
#include <boost/geometry.hpp>
#include <boost/geometry/index/rtree.hpp>
#include <boost/optional.hpp>
#include <rapidjson/document.h>
#include <optional>
#include <chrono>
namespace osrm::updater
@ -34,7 +34,7 @@ class Timezoner
Timezoner(const char geojson[], std::time_t utc_time_now);
Timezoner(const boost::filesystem::path &tz_shapes_filename, std::time_t utc_time_now);
boost::optional<struct tm> operator()(const point_t &point) const;
std::optional<struct tm> operator()(const point_t &point) const;
private:
void LoadLocalTimesRTree(rapidjson::Document &geojson, std::time_t utc_time);

8
src/guidance/intersection_handler.cpp
View File

@ -427,7 +427,7 @@ void IntersectionHandler::assignTrivialTurns(const EdgeID via_eid,
}
}
boost::optional<IntersectionHandler::IntersectionViewAndNode>
std::optional<IntersectionHandler::IntersectionViewAndNode>
IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) const
{
// We use the intersection generator to jump over traffic signals, barriers. The intersection
@ -450,7 +450,7 @@ IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) cons
if (intersection_parameters.node == SPECIAL_NODEID ||
intersection_parameters.edge == SPECIAL_EDGEID)
{
return boost::none;
return {};
}
auto intersection = extractor::intersection::getConnectedRoads<false>(node_based_graph,
@ -465,10 +465,10 @@ IntersectionHandler::getNextIntersection(const NodeID at, const EdgeID via) cons
if (intersection.size() <= 2 || intersection.isTrafficSignalOrBarrier())
{
return boost::none;
return {};
}
return boost::make_optional(
return std::make_optional(
IntersectionViewAndNode{std::move(intersection), intersection_node});
}

18
src/guidance/sliproad_handler.cpp
View File

@ -634,7 +634,7 @@ Intersection SliproadHandler::operator()(const NodeID /*nid*/,
// Implementation details
boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
std::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
const EdgeID from, const Intersection &intersection, const NodeID at) const
{
BOOST_ASSERT(from != SPECIAL_EDGEID);
@ -645,14 +645,14 @@ boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
if (index != 0)
{
return boost::make_optional(index);
return std::make_optional(index);
}
// Otherwise check if the road is forking into two and one of them is a Sliproad;
// then the non-Sliproad is the obvious one.
if (intersection.size() != 3)
{
return boost::none;
return {};
}
const auto forking = intersection[1].instruction.type == TurnType::Fork &&
@ -660,7 +660,7 @@ boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
if (!forking)
{
return boost::none;
return {};
}
const auto first = getNextIntersection(at, intersection.getRightmostRoad().eid);
@ -668,27 +668,27 @@ boost::optional<std::size_t> SliproadHandler::getObviousIndexWithSliproads(
if (!first || !second)
{
return boost::none;
return {};
}
if (first->intersection.isDeadEnd() || second->intersection.isDeadEnd())
{
return boost::none;
return {};
}
// In case of loops at the end of the road, we will arrive back at the intersection
// itself. If that is the case, the road is obviously not a sliproad.
if (canBeTargetOfSliproad(first->intersection) && at != second->node)
{
return boost::make_optional(std::size_t{2});
return std::make_optional(std::size_t{2});
}
if (canBeTargetOfSliproad(second->intersection) && at != first->node)
{
return boost::make_optional(std::size_t{1});
return std::make_optional(std::size_t{1});
}
return boost::none;
return {};
}
bool SliproadHandler::nextIntersectionIsTooFarAway(const NodeID start, const EdgeID onto) const

10
src/guidance/turn_handler.cpp
View File

@ -7,9 +7,9 @@
#include <algorithm>
#include <limits>
#include <utility>
#include <optional>
#include <boost/assert.hpp>
#include <boost/optional.hpp>
using osrm::util::angularDeviation;
@ -590,7 +590,7 @@ Intersection TurnHandler::assignRightTurns(const EdgeID via_edge,
}
// finds a fork candidate by just looking at the geometry and angle of an intersection
boost::optional<TurnHandler::Fork>
std::optional<TurnHandler::Fork>
TurnHandler::findForkCandidatesByGeometry(Intersection &intersection) const
{
if (intersection.size() >= 3)
@ -647,7 +647,7 @@ TurnHandler::findForkCandidatesByGeometry(Intersection &intersection) const
}
}
}
return boost::none;
return {};
}
// check if the fork candidates (all roads between left and right) and the
@ -695,7 +695,7 @@ bool TurnHandler::isCompatibleByRoadClass(const Intersection &intersection, cons
// Checks whether a three-way-intersection coming from `via_edge` is a fork
// with `intersection` as described as in #IntersectionExplanation@intersection_handler.hpp
boost::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
std::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
Intersection &intersection) const
{
auto fork = findForkCandidatesByGeometry(intersection);
@ -740,7 +740,7 @@ boost::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
}
}
return boost::none;
return {};
}
void TurnHandler::handleDistinctConflict(const EdgeID via_edge,

13
src/util/coordinate_calculation.cpp
View File

@ -6,6 +6,7 @@
#include <boost/assert.hpp>
#include <optional>
#include <algorithm>
#include <iterator>
#include <limits>
@ -173,14 +174,14 @@ double computeAngle(const Coordinate first, const Coordinate second, const Coord
return angle;
}
boost::optional<Coordinate>
std::optional<Coordinate>
circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
{
// free after http://paulbourke.net/geometry/circlesphere/
// require three distinct points
if (C1 == C2 || C2 == C3 || C1 == C3)
{
return boost::none;
{
return {};
}
// define line through c1, c2 and c2,c3
@ -195,7 +196,7 @@ circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
(std::abs(C2C1_lat) < std::numeric_limits<double>::epsilon() &&
std::abs(C3C2_lat) < std::numeric_limits<double>::epsilon()))
{
return boost::none;
return {};
}
else if (std::abs(C2C1_lon) < std::numeric_limits<double>::epsilon())
{
@ -233,7 +234,7 @@ circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
// can this ever happen?
if (std::abs(C2C1_slope - C3C2_slope) < std::numeric_limits<double>::epsilon())
return boost::none;
return {};
const double C1_y = static_cast<double>(toFloating(C1.lat));
const double C1_x = static_cast<double>(toFloating(C1.lon));
@ -247,7 +248,7 @@ circleCenter(const Coordinate C1, const Coordinate C2, const Coordinate C3)
(2 * (C3C2_slope - C2C1_slope));
const double lat = (0.5 * (C1_x + C2_x) - lon) / C2C1_slope + 0.5 * (C1_y + C2_y);
if (lon < -180.0 || lon > 180.0 || lat < -90.0 || lat > 90.0)
return boost::none;
return {};
else
return Coordinate(FloatLongitude{lon}, FloatLatitude{lat});
}

8
src/util/geojson_debug_policies.cpp
View File

@ -17,7 +17,7 @@ NodeIdVectorToLineString::NodeIdVectorToLineString(
// converts a vector of node ids into a linestring geojson feature
util::json::Object
NodeIdVectorToLineString::operator()(const std::vector<NodeID> &node_ids,
const boost::optional<json::Object> &properties) const
const std::optional<json::Object> &properties) const
{
util::json::Array coordinates;
std::transform(node_ids.begin(),
@ -37,7 +37,7 @@ NodeIdVectorToMultiPoint::NodeIdVectorToMultiPoint(
util::json::Object
NodeIdVectorToMultiPoint::operator()(const std::vector<NodeID> &node_ids,
const boost::optional<json::Object> &properties) const
const std::optional<json::Object> &properties) const
{
util::json::Array coordinates;
std::transform(node_ids.begin(),
@ -51,7 +51,7 @@ NodeIdVectorToMultiPoint::operator()(const std::vector<NodeID> &node_ids,
//----------------------------------------------------------------
util::json::Object
CoordinateVectorToMultiPoint::operator()(const std::vector<util::Coordinate> &input_coordinates,
const boost::optional<json::Object> &properties) const
const std::optional<json::Object> &properties) const
{
auto coordinates = makeJsonArray(input_coordinates);
return makeFeature("MultiPoint", std::move(coordinates), properties);
@ -60,7 +60,7 @@ CoordinateVectorToMultiPoint::operator()(const std::vector<util::Coordinate> &in
//----------------------------------------------------------------
util::json::Object
CoordinateVectorToLineString::operator()(const std::vector<util::Coordinate> &input_coordinates,
const boost::optional<json::Object> &properties) const
const std::optional<json::Object> &properties) const
{
auto coordinates = makeJsonArray(input_coordinates);
return makeFeature("LineString", std::move(coordinates), properties);

6
src/util/timezones.cpp
View File

@ -5,12 +5,12 @@
#include <boost/filesystem/fstream.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/optional.hpp>
#include <rapidjson/document.h>
#include <rapidjson/error/en.h>
#include <rapidjson/istreamwrapper.h>
#include <optional>
#include <fstream>
#include <regex>
#include <string>
@ -158,7 +158,7 @@ void Timezoner::LoadLocalTimesRTree(rapidjson::Document &geojson, std::time_t ut
rtree = rtree_t(polygons);
}
boost::optional<struct tm> Timezoner::operator()(const point_t &point) const
std::optional<struct tm> Timezoner::operator()(const point_t &point) const
{
std::vector<rtree_t::value_type> result;
rtree.query(boost::geometry::index::intersects(point), std::back_inserter(result));
@ -168,6 +168,6 @@ boost::optional<struct tm> Timezoner::operator()(const point_t &point) const
if (boost::geometry::within(point, local_times[index].first))
return local_times[index].second;
}
return boost::none;
return {};
}
} // namespace osrm::updater