LaneOperation.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/lane/LaneIdValidInputRange.hpp"
#include "ad/map/lane/LaneValidInputRange.hpp"
#include "ad/map/lane/Types.hpp"
#include "ad/map/match/Types.hpp"
#include "ad/map/point/BoundingSphereOperation.hpp"
#include "ad/map/point/Types.hpp"
#include "ad/map/restriction/RestrictionOperation.hpp"
#include "ad/physics/Duration.hpp"
 
namespace ad {
namespace map {
namespace lane {
 
inline bool isValid(LaneId const &laneId, bool const logErrors = true)
{
  return withinValidInputRange(laneId, logErrors);
}
 
inline bool isValid(Lane const &lane, bool const logErrors = true)
{
  return withinValidInputRange(lane, logErrors);
}
 
Lane::ConstPtr getLanePtr(LaneId const &id);
 
Lane const &getLane(lane::LaneId const &id);
 
LaneIdList getLanes();
 
point::ECEFHeading getLaneECEFHeading(match::MapMatchedPosition const &mapMatchedPosition);
 
point::ECEFHeading getLaneECEFHeading(point::ParaPoint const &paraPoint);
 
point::ENUHeading getLaneENUHeading(match::MapMatchedPosition const &mapMatchedPosition);
 
point::ENUHeading getLaneENUHeading(point::ParaPoint const &paraPoint, point::GeoPoint const &gnssReference);
 
LaneId uniqueLaneId(point::GeoPoint const &point);
 
point::ParaPoint uniqueParaPoint(point::GeoPoint const &point);
 
inline bool isAccessOk(Lane const &lane, restriction::VehicleDescriptor const &vehicle)
{
  return isAccessOk(lane.restrictions, vehicle);
}
 
inline bool isNear(Lane const &lane, point::BoundingSphere const &boundingSphere)
{
  return distance(lane.boundingSphere, boundingSphere) == physics::Distance(0.);
}
 
physics::Distance getWidth(Lane const &lane, physics::ParametricValue const &longitudinalOffset);
 
physics::Speed getMaxSpeed(Lane const &lane, physics::ParametricRange const &range);
 
restriction::SpeedLimitList getSpeedLimits(Lane const &lane, physics::ParametricRange const &range);
 
physics::Duration getDuration(Lane const &lane, physics::ParametricRange const &range);
 
inline restriction::PassengerCount getHOV(Lane const &lane)
{
  return getHOV(lane.restrictions);
}
 
ContactLaneList getContactLanes(Lane const &lane, ContactLocation const &location);
 
ContactLaneList getContactLanes(Lane const &lane, ContactLocationList const &locations);
 
ContactLocation getContactLocation(Lane const &lane, LaneId const &to_lane_id);
 
inline bool isLaneDirectionPositive(Lane const &lane)
{
  return lane.direction == LaneDirection::POSITIVE || lane.direction == LaneDirection::BIDIRECTIONAL;
}
 
inline bool isLaneDirectionNegative(Lane const &lane)
{
  return lane.direction == LaneDirection::NEGATIVE || lane.direction == LaneDirection::BIDIRECTIONAL;
}
 
inline bool isRouteable(Lane const &lane)
{
  return lane.type == LaneType::INTERSECTION || lane.type == LaneType::MULTI || lane.type == LaneType::NORMAL
    || lane.type == LaneType::TURN;
}
 
inline bool isLanePartOfAnIntersection(Lane const &lane)
{
  return (lane.type == lane::LaneType::INTERSECTION);
}
 
inline bool isLeftMost(Lane const &lane)
{
  return getContactLanes(lane, ContactLocation::LEFT).empty();
}
 
inline bool isRightMost(Lane const &lane)
{
  return getContactLanes(lane, ContactLocation::RIGHT).empty();
}
 
point::ECEFPoint getParametricPoint(Lane const &lane,
                                    physics::ParametricValue const &longitudinalOffset,
                                    physics::ParametricValue const &lateralOffset);
 
bool projectParametricPointToEdges(Lane const &lane,
                                   point::ECEFPoint const &referencePoint,
                                   point::ECEFPoint &point_on_left_edge,
                                   point::ECEFPoint &point_on_right_edge);
 
bool projectParametricPointToEdges(Lane const &lane,
                                   physics::ParametricValue const &longitudinalOffset,
                                   point::ECEFPoint &point_on_left_edge,
                                   point::ECEFPoint &point_on_right_edge);
 
point::ECEFPoint getProjectedParametricPoint(Lane const &lane,
                                             physics::ParametricValue const &longitudinalOffset,
                                             physics::ParametricValue const &lateralOffset);
 
inline point::ECEFPoint getStartPoint(Lane const &lane)
{
  return getParametricPoint(lane, physics::ParametricValue(0.), physics::ParametricValue(0.5));
}
 
inline point::ECEFPoint getEndPoint(Lane const &lane)
{
  return getParametricPoint(lane, physics::ParametricValue(1.), physics::ParametricValue(0.5));
}
 
bool isPyhsicalSuccessor(Lane const &lane, Lane const &other);
 
bool isPhysicalPredecessor(Lane const &lane, Lane const &other);
 
bool isVanishingLaneStart(Lane const &lane);
 
bool isVanishingLaneEnd(Lane const &lane);
 
bool satisfiesFilter(Lane const &lane, std::string const &typeFilter, bool isHov);
 
ContactLocation getDirectNeighborhoodRelation(LaneId const laneId, LaneId const checkLaneId);
 
bool isSuccessorOrPredecessor(LaneId const laneId, LaneId const checkLaneId);
 
bool isSameOrDirectNeighbor(LaneId const id, LaneId const neighbor);
 
bool isLaneDirectionPositive(LaneId const &laneId);
 
bool isLaneDirectionNegative(LaneId const &laneId);
 
physics::Distance getDistanceToLane(LaneId laneId, match::Object const &object);
 
point::ENUHeading getLaneENUHeading(point::ParaPoint const &position);
 
bool isHeadingInLaneDirection(point::ParaPoint const &position, point::ENUHeading const &heading);
 
bool projectPositionToLaneInHeadingDirection(point::ParaPoint const &position,
                                             point::ENUHeading const &heading,
                                             point::ParaPoint &projectedPosition);
 
bool findNearestPointOnLane(Lane const &lane, point::ECEFPoint const &pt, match::MapMatchedPosition &mmpos);
 
bool findNearestPointOnLaneInterval(route::LaneInterval const &laneInterval,
                                    point::ECEFPoint const &pt,
                                    match::MapMatchedPosition &mmpos);
 
point::ENUPoint getENULanePoint(point::ParaPoint const parametricPoint,
                                physics::ParametricValue const &lateralOffset = physics::ParametricValue(0.5));
 
physics::Distance calcLength(LaneId const &laneId);
 
physics::Distance calcLength(match::LaneOccupiedRegion const &laneOccupiedRegion);
 
physics::Distance calcWidth(point::ParaPoint const &paraPoint);
 
physics::Distance calcWidth(LaneId const &laneId, physics::ParametricValue const &longOffset);
 
physics::Distance calcWidth(point::ENUPoint const &enuPoint);
 
physics::Distance calcWidth(match::LaneOccupiedRegion const &laneOccupiedRegion);
 
struct LaneAltitudeRange
{
  point::Altitude minimum;
  point::Altitude maximum;
};
 
LaneAltitudeRange calcLaneAltitudeRange(Lane const &lane);
 
bool isLaneRelevantForExpansion(lane::LaneId const &laneId, lane::LaneIdSet const &relevantLanes);
 
} // namespace lane
} // namespace map
} // namespace ad