LaneIntervalOperation.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/access/Types.hpp"
#include "ad/map/lane/Types.hpp"
#include "ad/map/route/Types.hpp"
 
namespace ad {
namespace map {
namespace route {
 
inline point::ParaPoint getIntervalStart(LaneInterval const &laneInterval)
{
  point::ParaPoint result;
  result.laneId = laneInterval.laneId;
  result.parametricOffset = laneInterval.start;
  return result;
}
 
point::ParaPoint getIntervalStart(FullRoute const &route, lane::LaneId const &laneId);
 
inline point::ParaPoint getIntervalEnd(LaneInterval const &laneInterval)
{
  point::ParaPoint result;
  result.laneId = laneInterval.laneId;
  result.parametricOffset = laneInterval.end;
  return result;
}
 
inline physics::ParametricRange toParametricRange(route::LaneInterval const &laneInterval)
{
  physics::ParametricRange range;
  if (laneInterval.start <= laneInterval.end)
  {
    range.minimum = laneInterval.start;
    range.maximum = laneInterval.end;
  }
  else
  {
    range.minimum = laneInterval.end;
    range.maximum = laneInterval.start;
  }
  return range;
}
 
physics::ParametricValue
getSignedDistance(LaneInterval const &laneInterval, point::ParaPoint const &first, point::ParaPoint const &second);
 
physics::ParametricValue
getUnsignedDistance(LaneInterval const &laneInterval, point::ParaPoint const &first, point::ParaPoint const &second);
 
inline bool isStartOfInterval(LaneInterval const &laneInterval, point::ParaPoint const &point)
{
  return (point.laneId == laneInterval.laneId) && (point.parametricOffset == laneInterval.start);
}
 
inline bool isEndOfInterval(LaneInterval const &laneInterval, point::ParaPoint const &point)
{
  return (point.laneId == laneInterval.laneId) && (point.parametricOffset == laneInterval.end);
}
 
bool isRouteDirectionPositive(LaneInterval const &laneInterval);
 
inline bool isRouteDirectionNegative(LaneInterval const &laneInterval)
{
  return !isRouteDirectionPositive(laneInterval);
}
 
bool isRouteDirectionAlignedWithDrivingDirection(LaneInterval const &laneInterval);
 
inline bool isWithinInterval(LaneInterval const &laneInterval, physics::ParametricValue const &parametricOffset)
{
  if (isRouteDirectionPositive(laneInterval))
  {
    return (laneInterval.start <= parametricOffset) && (parametricOffset <= laneInterval.end);
  }
  else
  {
    return (laneInterval.end <= parametricOffset) && (parametricOffset <= laneInterval.start);
  }
}
 
inline bool isWithinInterval(LaneInterval const &laneInterval, point::ParaPoint const &point)
{
  return (point.laneId == laneInterval.laneId) && isWithinInterval(laneInterval, point.parametricOffset);
}
 
inline bool isDegenerated(LaneInterval const &laneInterval)
{
  return (laneInterval.start == laneInterval.end);
}
 
inline bool isAfterInterval(LaneInterval const &laneInterval, physics::ParametricValue const parametricOffset)
{
  if (isRouteDirectionPositive(laneInterval))
  {
    return (parametricOffset > laneInterval.end);
  }
  else
  {
    return (parametricOffset < laneInterval.end);
  }
}
 
inline bool isAfterInterval(LaneInterval const &laneInterval, point::ParaPoint const &point)
{
  if (point.laneId == laneInterval.laneId)
  {
    return isAfterInterval(laneInterval, point.parametricOffset);
  }
  return false;
}
 
inline bool isBeforeInterval(LaneInterval const &laneInterval, physics::ParametricValue const parametricOffset)
{
  if (isRouteDirectionPositive(laneInterval))
  {
    return (parametricOffset < laneInterval.start);
  }
  else
  {
    return (parametricOffset > laneInterval.start);
  }
}
 
inline bool isBeforeInterval(LaneInterval const &laneInterval, point::ParaPoint const &point)
{
  if (point.laneId == laneInterval.laneId)
  {
    return isBeforeInterval(laneInterval, point.parametricOffset);
  }
  return false;
}
 
inline bool overlapsInterval(LaneInterval const &laneInterval, physics::ParametricRange const &range)
{
  bool rangeIsOutside = (isBeforeInterval(laneInterval, range.minimum) && isBeforeInterval(laneInterval, range.maximum))
    || (isAfterInterval(laneInterval, range.minimum) && isAfterInterval(laneInterval, range.maximum));
  return !rangeIsOutside;
}
 
physics::ParametricValue getProjectedParametricOffsetOnNeighborLane(LaneInterval const &currentInterval,
                                                                    LaneInterval const &neighborInterval,
                                                                    physics::ParametricValue const &parametricOffset);
 
inline physics::ParametricValue calcParametricLength(LaneInterval const &laneInterval)
{
  return std::fabs(laneInterval.start - laneInterval.end);
}
 
physics::Distance calcLength(LaneInterval const &laneInterval);
 
physics::Duration calcDuration(LaneInterval const &laneInterval);
 
void getRightEdge(LaneInterval const &laneInterval, point::ENUEdge &enuEdge);
 
void getRightEdge(LaneInterval const &laneInterval, point::ECEFEdge &ecefEdge);
 
void getRightEdge(LaneInterval const &laneInterval, point::GeoEdge &geoEdge);
 
point::ENUEdge getRightENUEdge(LaneInterval const &laneInterval);
 
point::ECEFEdge getRightECEFEdge(LaneInterval const &laneInterval);
 
point::GeoEdge getRightGeoEdge(LaneInterval const &laneInterval);
 
void getRightProjectedEdge(LaneInterval const &laneInterval, point::ENUEdge &enuEdge);
 
void getRightProjectedEdge(LaneInterval const &laneInterval, point::ECEFEdge &ecefEdge);
 
void getRightProjectedEdge(LaneInterval const &laneInterval, point::GeoEdge &geoEdge);
 
point::ENUEdge getRightProjectedENUEdge(LaneInterval const &laneInterval);
 
point::ECEFEdge getRightProjectedECEFEdge(LaneInterval const &laneInterval);
 
point::GeoEdge getRightProjectedGeoEdge(LaneInterval const &laneInterval);
 
void getLeftEdge(LaneInterval const &laneInterval, point::ENUEdge &enuEdge);
 
void getLeftEdge(LaneInterval const &laneInterval, point::ECEFEdge &ecefEdge);
 
void getLeftEdge(LaneInterval const &laneInterval, point::GeoEdge &geoEdge);
 
point::ENUEdge getLeftENUEdge(LaneInterval const &laneInterval);
 
point::ECEFEdge getLeftECEFEdge(LaneInterval const &laneInterval);
 
point::GeoEdge getLeftGeoEdge(LaneInterval const &laneInterval);
 
void getLeftProjectedEdge(LaneInterval const &laneInterval, point::ENUEdge &enuEdge);
 
void getLeftProjectedEdge(LaneInterval const &laneInterval, point::ECEFEdge &ecefEdge);
 
void getLeftProjectedEdge(LaneInterval const &laneInterval, point::GeoEdge &geoEdge);
 
point::ENUEdge getLeftProjectedENUEdge(LaneInterval const &laneInterval);
 
point::ECEFEdge getLeftProjectedECEFEdge(LaneInterval const &laneInterval);
 
point::GeoEdge getLeftProjectedGeoEdge(LaneInterval const &laneInterval);
 
lane::GeoBorder getGeoBorder(LaneInterval const &laneInterval);
 
lane::ECEFBorder getECEFBorder(LaneInterval const &laneInterval);
 
lane::ENUBorder getENUBorder(LaneInterval const &laneInterval);
 
lane::ENUBorder getENUProjectedBorder(LaneInterval const &laneInterval);
 
LaneInterval shortenIntervalFromBegin(LaneInterval const &laneInterval, physics::Distance const &distance);
 
LaneInterval shortenIntervalFromEnd(LaneInterval const &laneInterval, physics::Distance const &distance);
 
LaneInterval restrictIntervalFromBegin(LaneInterval const &laneInterval, physics::Distance const &distance);
 
LaneInterval extendIntervalUntilEnd(LaneInterval const &laneInterval);
 
LaneInterval cutIntervalAtStart(LaneInterval const &laneInterval, physics::ParametricValue const &newIntervalStart);
 
LaneInterval extendIntervalUntilStart(LaneInterval const &laneInterval);
 
LaneInterval extendIntervalFromStart(LaneInterval const &laneInterval, physics::Distance const &distance);
 
LaneInterval extendIntervalFromEnd(LaneInterval const &laneInterval, physics::Distance const &distance);
 
LaneInterval cutIntervalAtEnd(LaneInterval const &laneInterval, physics::ParametricValue const &newIntervalEnd);
 
restriction::SpeedLimitList getSpeedLimits(LaneInterval const &laneInterval);
 
void getMetricRanges(LaneInterval const &laneInterval,
                     physics::MetricRange &lengthRange,
                     physics::MetricRange &widthRange);
 
} // namespace route
} // namespace map
} // namespace ad