Planning.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: MIT
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include "ad/map/config/PointOfInterest.hpp"
#include "ad/map/match/Object.hpp"
#include "ad/map/route/Route.hpp"
#include "ad/map/route/RouteOperation.hpp"
#include "ad/map/route/Routing.hpp"
#include "ad/map/route/Types.hpp"
 
namespace ad {
namespace map {
namespace route {
namespace planning {
 
RoutingParaPoint createRoutingPoint(lane::LaneId const &laneId,
                                    physics::ParametricValue const &parametricOffset,
                                    RoutingDirection const &routingDirection = RoutingDirection::DONT_CARE);
 
RoutingParaPoint createRoutingPoint(point::ParaPoint const &paraPoint,
                                    RoutingDirection const &routingDirection = RoutingDirection::DONT_CARE);
 
RoutingParaPoint createRoutingPoint(match::LaneOccupiedRegion const &occupiedRegion,
                                    RoutingDirection const &routingDirection = RoutingDirection::DONT_CARE);
 
RoutingParaPoint createRoutingPoint(point::ParaPoint const &paraPoint, point::ENUHeading const &heading);
 
RoutingParaPoint createRoutingPoint(match::LaneOccupiedRegion const &occupiedRegion, point::ENUHeading const &heading);
 
route::FullRoute planRoute(const RoutingParaPoint &start,
                           const RoutingParaPoint &dest,
                           RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection);
 
inline route::FullRoute planRoute(const point::ParaPoint &start,
                                  const point::ParaPoint &dest,
                                  RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection)
{
  return planRoute(createRoutingPoint(start), createRoutingPoint(dest), routeCreationMode);
}
 
inline route::FullRoute planRoute(const point::ParaPoint &start,
                                  point::ENUHeading const &startHeading,
                                  const point::ParaPoint &dest,
                                  RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection)
{
  return planRoute(createRoutingPoint(start, startHeading), createRoutingPoint(dest), routeCreationMode);
}
 
inline route::FullRoute planRoute(const point::ParaPoint &start,
                                  point::ENUHeading const &startHeading,
                                  const point::ParaPoint &dest,
                                  point::ENUHeading const &destHeading,
                                  RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection)
{
  return planRoute(createRoutingPoint(start, startHeading), createRoutingPoint(dest, destHeading), routeCreationMode);
}
 
route::FullRoute planRoute(const RoutingParaPoint &start,
                           const point::GeoPoint &dest,
                           RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection);
 
route::FullRoute planRoute(const RoutingParaPoint &start,
                           const point::ENUPoint &dest,
                           RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection);
 
inline route::FullRoute planRoute(const point::ParaPoint &start,
                                  const point::GeoPoint &dest,
                                  RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection)
{
  return planRoute(createRoutingPoint(start), dest, routeCreationMode);
}
 
inline route::FullRoute planRoute(const point::ParaPoint &start,
                                  point::ENUHeading const &startHeading,
                                  const point::GeoPoint &dest,
                                  RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection)
{
  return planRoute(createRoutingPoint(start, startHeading), dest, routeCreationMode);
}
 
inline FullRoute planRoute(const point::ParaPoint &start,
                           const config::PointOfInterest &dest,
                           RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection)
{
  return planRoute(start, dest.geoPoint, routeCreationMode);
}
 
FullRoute planRoute(const RoutingParaPoint &start,
                    const std::vector<point::GeoPoint> &dest,
                    RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection);
 
FullRoute planRoute(const RoutingParaPoint &start,
                    const std::vector<point::ENUPoint> &dest,
                    RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection);
 
FullRoute planRoute(const RoutingParaPoint &start,
                    std::vector<RoutingParaPoint> const &dest,
                    RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection);
 
inline route::FullRoute planRoute(const point::ParaPoint &start,
                                  point::ENUHeading const &startHeading,
                                  const std::vector<point::GeoPoint> &dest,
                                  RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection)
{
  return planRoute(createRoutingPoint(start, startHeading), dest, routeCreationMode);
}
 
enum class FilterDuplicatesMode
{
  Off,
  OnlyEqual,
  SubRoutesPreferShorterOnes,
  SubRoutesPreferLongerOnes
};
 
std::vector<route::FullRoute>
predictRoutesOnDuration(const RoutingParaPoint &start,
                        physics::Duration const &predictionDuration,
                        RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection,
                        FilterDuplicatesMode const filterMode = FilterDuplicatesMode::SubRoutesPreferLongerOnes,
                        ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
std::vector<route::FullRoute>
predictRoutesOnDistance(const RoutingParaPoint &start,
                        physics::Distance const &predictionDistance,
                        RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection,
                        FilterDuplicatesMode const filterMode = FilterDuplicatesMode::SubRoutesPreferLongerOnes,
                        ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
std::vector<route::FullRoute>
predictRoutes(const RoutingParaPoint &start,
              physics::Distance const &predictionDistance,
              physics::Duration const &predictionDuration,
              RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection,
              FilterDuplicatesMode const filterMode = FilterDuplicatesMode::SubRoutesPreferLongerOnes,
              ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
std::vector<route::FullRoute>
predictRoutesOnDuration(const match::MapMatchedObjectBoundingBox &start,
                        physics::Duration const &predictionDuration,
                        RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection,
                        FilterDuplicatesMode const filterMode = FilterDuplicatesMode::SubRoutesPreferLongerOnes,
                        ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
std::vector<route::FullRoute>
predictRoutesOnDistance(const match::MapMatchedObjectBoundingBox &start,
                        physics::Distance const &predictionDistance,
                        RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection,
                        FilterDuplicatesMode const filterMode = FilterDuplicatesMode::SubRoutesPreferLongerOnes,
                        ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
std::vector<route::FullRoute>
predictRoutes(const match::MapMatchedObjectBoundingBox &start,
              physics::Distance const &predictionDistance,
              physics::Duration const &predictionDuration,
              RouteCreationMode const routeCreationMode = RouteCreationMode::SameDrivingDirection,
              FilterDuplicatesMode const filterMode = FilterDuplicatesMode::SubRoutesPreferLongerOnes,
              ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
std::vector<route::FullRoute>
predictRoutesDirectionless(const point::ParaPoint &start,
                           physics::Distance const &predictionDistance,
                           physics::Duration const &predictionDuration,
                           RouteCreationMode const routeCreationMode = RouteCreationMode::AllRoutableLanes,
                           FilterDuplicatesMode const filterMode = FilterDuplicatesMode::SubRoutesPreferLongerOnes,
                           ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
FullRouteList filterDuplicatedRoutes(const FullRouteList fullRoutes, FilterDuplicatesMode const filterMode);
 
enum class CompareRouteResult
{
  Equal,
  Shorter,
  Longer,
  Differ
};
 
std::ostream &operator<<(std::ostream &os, CompareRouteResult const &value);
 
CompareRouteResult compareRoutesOnIntervalLevel(FullRoute const &left, FullRoute const &right);
 
ConnectingRoute calculateConnectingRoute(
  const match::Object &startObject,
  const match::Object &destObject,
  physics::Distance const &maxDistance,
  physics::Duration const &maxDuration,
  std::vector<route::FullRoute> const &startObjectPredictionHints = std::vector<route::FullRoute>(),
  std::vector<route::FullRoute> const &destObjectPredictionHints = std::vector<route::FullRoute>(),
  ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
ConnectingRoute calculateConnectingRoute(
  const match::Object &startObject,
  const match::Object &destObject,
  physics::Distance const &maxDistance,
  std::vector<route::FullRoute> const &startObjectPredictionHints = std::vector<route::FullRoute>(),
  std::vector<route::FullRoute> const &destObjectPredictionHints = std::vector<route::FullRoute>(),
  ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
ConnectingRoute calculateConnectingRoute(
  const match::Object &startObject,
  const match::Object &destObject,
  physics::Duration const &maxDuration,
  std::vector<route::FullRoute> const &startObjectPredictionHints = std::vector<route::FullRoute>(),
  std::vector<route::FullRoute> const &destObjectPredictionHints = std::vector<route::FullRoute>(),
  ::ad::map::lane::LaneIdSet const &relevantLanes = ::ad::map::lane::LaneIdSet());
 
void updateRoutePlanningCounters(route::FullRoute &route);
 
FullRoute createFullRoute(const Route::RawRoute &rawRoute,
                          RouteCreationMode const routeCreationMode,
                          lane::LaneIdSet const &relevantLanes);
 
} // namespace planning
} // namespace route
} // namespace map
} // namespace ad