AdMapMatching.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 <list>
 
#include "ad/map/match/Types.hpp"
#include "ad/map/point/Operation.hpp"
#include "ad/map/route/Types.hpp"
 
namespace ad {
namespace map {
namespace match {
 
class AdMapMatching
{
public:
  AdMapMatching();
 
  ~AdMapMatching() = default;
 
  void setMaxHeadingHintFactor(double newHeadingHintFactor)
  {
    mHeadingHintFactor = std::max(1., newHeadingHintFactor);
  }
 
  double getMaxHeadingHintFactor() const
  {
    return mHeadingHintFactor;
  }
 
  void setRouteHintFactor(double newRouteHintFactor)
  {
    mRouteHintFactor = std::max(1., newRouteHintFactor);
  }
 
  double getRouteHintFactor() const
  {
    return mRouteHintFactor;
  }
 
  void addHeadingHint(point::ECEFHeading const &headingHint)
  {
    mHeadingHints.push_back(headingHint);
  }
 
  void addHeadingHint(point::ENUHeading const &yaw, point::GeoPoint const &enuReferencePoint)
  {
    mHeadingHints.push_back(point::createECEFHeading(yaw, enuReferencePoint));
  }
 
  void clearHeadingHints()
  {
    mHeadingHints.clear();
  }
 
  void addRouteHint(route::FullRoute const &routeHint)
  {
    mRouteHints.push_back(routeHint);
  }
 
  void clearRouteHints()
  {
    mRouteHints.clear();
  }
 
  void clearHints()
  {
    clearRouteHints();
    clearHeadingHints();
  }
 
  void setRelevantLanes(::ad::map::lane::LaneIdSet const &relevantLanes)
  {
    mRelevantLanes = relevantLanes;
  }
 
  void clearRelevantLanes()
  {
    mRelevantLanes.clear();
  }
 
  MapMatchedPositionConfidenceList getMapMatchedPositions(point::GeoPoint const &geoPoint,
                                                          physics::Distance const &distance,
                                                          physics::Probability const &minProbability) const;
 
  MapMatchedPositionConfidenceList getMapMatchedPositions(point::ENUPoint const &enuPoint,
                                                          point::GeoPoint const &enuReferencePoint,
                                                          physics::Distance const &distance,
                                                          physics::Probability const &minProbability) const;
 
  MapMatchedPositionConfidenceList getMapMatchedPositions(point::ENUPoint const &enuPoint,
                                                          physics::Distance const &distance,
                                                          physics::Probability const &minProbability) const;
 
  MapMatchedPositionConfidenceList getMapMatchedPositions(ENUObjectPosition const &enuObjectPosition,
                                                          physics::Distance const &distance,
                                                          physics::Probability const &minProbability);
 
  MapMatchedObjectBoundingBox getMapMatchedBoundingBox(ENUObjectPosition const &enuObjectPosition,
                                                       physics::Distance const &samplingDistance
                                                       = physics::Distance(1.)) const;
 
  LaneOccupiedRegionList getLaneOccupiedRegions(ENUObjectPositionList enuObjectPositionList,
                                                physics::Distance const &samplingDistance
                                                = physics::Distance(1.)) const;
 
  point::ENUHeading getLaneENUHeading(MapMatchedPosition const &mapMatchedPosition) const;
 
  static MapMatchedPositionConfidenceList findLanes(point::ECEFPoint const &ecefPoint,
                                                    physics::Distance const &distance,
                                                    ::ad::map::lane::LaneIdSet const &relevantLanes
                                                    = ::ad::map::lane::LaneIdSet());
 
  static MapMatchedPositionConfidenceList findLanes(point::GeoPoint const &geoPoint,
                                                    physics::Distance const &distance,
                                                    ::ad::map::lane::LaneIdSet const &relevantLanes
                                                    = ::ad::map::lane::LaneIdSet());
 
  static MapMatchedPositionConfidenceList findRouteLanes(point::ECEFPoint const &ecefPoint,
                                                         route::FullRoute const &route);
 
private:
  // Copy operators and constructors are deleted to avoid accidental copies
  AdMapMatching(AdMapMatching const &) = delete;
  AdMapMatching(AdMapMatching &&) = delete;
  AdMapMatching &operator=(AdMapMatching &&) = delete;
  AdMapMatching &operator=(AdMapMatching const &) = delete;
 
  static match::MapMatchedPositionConfidenceList findLanesInputChecked(point::ECEFPoint const &ecefPoint,
                                                                       physics::Distance const &distance,
                                                                       ::ad::map::lane::LaneIdSet const &relevantLanes);
 
  static match::MapMatchedPositionConfidenceList
  findLanesInputChecked(std::vector<lane::Lane::ConstPtr> const &relevantLanes,
                        point::ECEFPoint const &ecefPoint,
                        physics::Distance const &distance);
 
  static std::vector<lane::Lane::ConstPtr> getRelevantLanesInputChecked(point::ECEFPoint const &ecefPoint,
                                                                        physics::Distance const &distance);
  static void normalizeResults(match::MapMatchedPositionConfidenceList &mapMatchingResults,
                               physics::Probability const &probabilitySum);
 
  static match::MapMatchedPositionConfidenceList
  findLanesInputCheckedAltitudeUnknown(point::GeoPoint const &geoPoint,
                                       physics::Distance const &distance,
                                       ::ad::map::lane::LaneIdSet const &relevantLanes);
 
  static std::vector<lane::Lane::ConstPtr>
  getRelevantLanesInputChecked(point::ECEFPoint const &ecefPoint,
                               physics::Distance const &distance,
                               ::ad::map::lane::LaneIdSet const &relevantLanes);
 
  void addLaneRegions(LaneOccupiedRegionList &laneOccupiedRegions,
                      MapMatchedPositionConfidenceList const &mapMatchedPositions) const;
  void addLaneRegions(LaneOccupiedRegionList &laneOccupiedRegions,
                      LaneOccupiedRegionList const &otherLaneOccupiedRegions) const;
 
  MapMatchedPositionConfidenceList considerMapMatchingHints(MapMatchedPositionConfidenceList const &mapMatchedPositions,
                                                            physics::Probability const &minProbability) const;
  bool isLanePartOfRouteHints(lane::LaneId const &laneId) const;
  double getHeadingFactor(MapMatchedPosition const &matchedPosition) const;
 
  std::list<point::ECEFHeading> mHeadingHints;
  double mHeadingHintFactor{2.};
  std::list<route::FullRoute> mRouteHints;
  double mRouteHintFactor{10.};
 
  ::ad::map::lane::LaneIdSet mRelevantLanes;
};
 
} // namespace match
} // namespace map
} // namespace ad