167 lines
5.8 KiB
C++
167 lines
5.8 KiB
C++
#ifndef INTERNAL_EXTRACTOR_EDGE_HPP
|
|
#define INTERNAL_EXTRACTOR_EDGE_HPP
|
|
|
|
#include "extractor/guidance/road_classification.hpp"
|
|
#include "extractor/guidance/turn_lane_types.hpp"
|
|
#include "extractor/node_based_edge.hpp"
|
|
#include "extractor/travel_mode.hpp"
|
|
#include "osrm/coordinate.hpp"
|
|
#include "util/strong_typedef.hpp"
|
|
#include "util/typedefs.hpp"
|
|
|
|
#include <boost/assert.hpp>
|
|
#include <mapbox/variant.hpp>
|
|
#include <utility>
|
|
|
|
namespace osrm
|
|
{
|
|
namespace extractor
|
|
{
|
|
|
|
namespace detail
|
|
{
|
|
// these are used for duration based mode of transportations like ferries
|
|
OSRM_STRONG_TYPEDEF(double, ValueByEdge)
|
|
OSRM_STRONG_TYPEDEF(double, ValueByMeter)
|
|
using ByEdgeOrByMeterValue = mapbox::util::variant<detail::ValueByEdge, detail::ValueByMeter>;
|
|
|
|
struct ToValueByEdge
|
|
{
|
|
ToValueByEdge(double distance_) : distance(distance_) {}
|
|
|
|
ValueByEdge operator()(const ValueByMeter by_meter) const
|
|
{
|
|
return ValueByEdge{distance / static_cast<double>(by_meter)};
|
|
}
|
|
|
|
ValueByEdge operator()(const ValueByEdge by_edge) const { return by_edge; }
|
|
|
|
double distance;
|
|
};
|
|
}
|
|
|
|
struct InternalExtractorEdge
|
|
{
|
|
using WeightData = detail::ByEdgeOrByMeterValue;
|
|
using DurationData = detail::ByEdgeOrByMeterValue;
|
|
|
|
explicit InternalExtractorEdge()
|
|
: result(MIN_OSM_NODEID,
|
|
MIN_OSM_NODEID,
|
|
SPECIAL_NODEID,
|
|
0,
|
|
0,
|
|
false, // forward
|
|
false, // backward
|
|
false, // roundabout
|
|
false, // circular
|
|
true, // can be startpoint
|
|
TRAVEL_MODE_INACCESSIBLE,
|
|
false,
|
|
guidance::TurnLaneType::empty,
|
|
guidance::RoadClassification()),
|
|
weight_data(detail::ValueByMeter{0.0}), duration_data(detail::ValueByMeter{0.0})
|
|
{
|
|
}
|
|
|
|
explicit InternalExtractorEdge(OSMNodeID source,
|
|
OSMNodeID target,
|
|
NodeID name_id,
|
|
WeightData weight_data,
|
|
DurationData duration_data,
|
|
bool forward,
|
|
bool backward,
|
|
bool roundabout,
|
|
bool circular,
|
|
bool startpoint,
|
|
TravelMode travel_mode,
|
|
bool is_split,
|
|
LaneDescriptionID lane_description,
|
|
guidance::RoadClassification road_classification,
|
|
util::Coordinate source_coordinate)
|
|
: result(source,
|
|
target,
|
|
name_id,
|
|
0,
|
|
0,
|
|
forward,
|
|
backward,
|
|
roundabout,
|
|
circular,
|
|
startpoint,
|
|
travel_mode,
|
|
is_split,
|
|
lane_description,
|
|
std::move(road_classification)),
|
|
weight_data(std::move(weight_data)), duration_data(std::move(duration_data)),
|
|
source_coordinate(std::move(source_coordinate))
|
|
{
|
|
}
|
|
|
|
// data that will be written to disk
|
|
NodeBasedEdgeWithOSM result;
|
|
// intermediate edge weight
|
|
WeightData weight_data;
|
|
// intermediate edge duration
|
|
DurationData duration_data;
|
|
// coordinate of the source node
|
|
util::Coordinate source_coordinate;
|
|
|
|
// necessary static util functions for stxxl's sorting
|
|
static InternalExtractorEdge min_osm_value()
|
|
{
|
|
return InternalExtractorEdge(MIN_OSM_NODEID,
|
|
MIN_OSM_NODEID,
|
|
SPECIAL_NODEID,
|
|
detail::ValueByMeter{0.0},
|
|
detail::ValueByMeter{0.0},
|
|
false, // forward
|
|
false, // backward
|
|
false, // roundabout
|
|
false, // circular
|
|
true, // can be startpoint
|
|
TRAVEL_MODE_INACCESSIBLE,
|
|
false,
|
|
INVALID_LANE_DESCRIPTIONID,
|
|
guidance::RoadClassification(),
|
|
util::Coordinate());
|
|
}
|
|
static InternalExtractorEdge max_osm_value()
|
|
{
|
|
return InternalExtractorEdge(MAX_OSM_NODEID,
|
|
MAX_OSM_NODEID,
|
|
SPECIAL_NODEID,
|
|
detail::ValueByMeter{0.0},
|
|
detail::ValueByMeter{0.0},
|
|
false, // forward
|
|
false, // backward
|
|
false, // roundabout
|
|
false, // circular
|
|
true, // can be startpoint
|
|
TRAVEL_MODE_INACCESSIBLE,
|
|
false,
|
|
INVALID_LANE_DESCRIPTIONID,
|
|
guidance::RoadClassification(),
|
|
util::Coordinate());
|
|
}
|
|
|
|
static InternalExtractorEdge min_internal_value()
|
|
{
|
|
auto v = min_osm_value();
|
|
v.result.source = 0;
|
|
v.result.target = 0;
|
|
return v;
|
|
}
|
|
static InternalExtractorEdge max_internal_value()
|
|
{
|
|
auto v = max_osm_value();
|
|
v.result.source = std::numeric_limits<NodeID>::max();
|
|
v.result.target = std::numeric_limits<NodeID>::max();
|
|
return v;
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
#endif // INTERNAL_EXTRACTOR_EDGE_HPP
|