RoutePrediction.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 <deque>
#include <map>
#include "ad/map/route/RouteExpander.hpp"
#include "ad/map/route/Routing.hpp"
 
namespace ad {
namespace map {
namespace route {
namespace planning {
 
struct RoutePredictionScore
{
};
 
class RoutePrediction : public RouteExpander<RoutePredictionScore>
{
public:
  using RouteExpander::RoutingPoint;
 
  RoutePrediction(const RoutingParaPoint &start,
                  physics::Distance const &predictionDistance,
                  physics::Duration const &predictionDuration,
                  Type typ = Route::Type::SHORTEST);
 
  RoutePrediction(const RoutingParaPoint &start,
                  physics::Distance const &predictionDistance,
                  Type typ = Route::Type::SHORTEST);
 
  RoutePrediction(const RoutingParaPoint &start,
                  physics::Duration const &predictionDuration,
                  Type typ = Route::Type::SHORTEST);
 
  bool calculate() override;
 
private:
  void addNeighbor(lane::Lane::ConstPtr originLane,
                   RoutingPoint const &origin,
                   lane::Lane::ConstPtr neighborLane,
                   RoutingPoint const &neighbor,
                   ExpandReason const &expandReason) override;
 
  void insertNeighbor(RoutingPoint const &origin, RoutingPoint const &neighbor);
 
  struct RouteTreeElement
  {
    RouteTreeElement(RouteTreeElement const *parent, RoutingPoint const &iRoutingPoint)
      : routingPoint(iRoutingPoint)
      , theParent(parent)
    {
    }
 
    struct RouteTreeElementCompare
    {
      bool operator()(const std::shared_ptr<RouteTreeElement> &left,
                      const std::shared_ptr<RouteTreeElement> &right) const
      {
        return left->routingPoint.first < right->routingPoint.first;
      }
    };
 
    typedef std::set<std::shared_ptr<RouteTreeElement>, RouteTreeElementCompare> RouteTreeElementUniqueRoutePointSet;
 
    RoutingPoint routingPoint;
    RouteTreeElementUniqueRoutePointSet children;
    RouteTreeElement const *theParent;
  };
 
  void reconstructPaths();
 
  std::shared_ptr<RouteTreeElement> mRouteTreeRoot;
 
  std::map<RoutingParaPoint, RouteTreeElement::RouteTreeElementUniqueRoutePointSet> mProcessedTransitions;
 
  std::deque<std::shared_ptr<RouteTreeElement>> mElementsToProcess;
};
 
} // namespace planning
} // namespace route
} // namespace map
} // namespace ad