BasicRegulatoryElements.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include "lanelet2_core/Forward.h"
#include "lanelet2_core/primitives/LineString.h"
#include "lanelet2_core/primitives/LineStringOrPolygon.h"
#include "lanelet2_core/primitives/RegulatoryElement.h"
 
namespace lanelet {
 
class TrafficLight : public RegulatoryElement {
 public:
  using Ptr = std::shared_ptr<TrafficLight>;
  static constexpr char RuleName[] = "traffic_light";
  static Ptr make(Id id, const AttributeMap& attributes, const LineStringsOrPolygons3d& trafficLights,
                  const Optional<LineString3d>& stopLine = {}) {
    return Ptr{new TrafficLight(id, attributes, trafficLights, stopLine)};
  }
 
  Optional<ConstLineString3d> stopLine() const;
  Optional<LineString3d> stopLine();
 
  ConstLineStringsOrPolygons3d trafficLights() const;
  LineStringsOrPolygons3d trafficLights();
 
  void addTrafficLight(const LineStringOrPolygon3d& primitive);
 
  bool removeTrafficLight(const LineStringOrPolygon3d& primitive);
 
  void setStopLine(const LineString3d& stopLine);
 
  void removeStopLine();
 
 protected:
  friend class RegisterRegulatoryElement<TrafficLight>;
  TrafficLight(Id id, const AttributeMap& attributes, const LineStringsOrPolygons3d& trafficLights,
               const Optional<LineString3d>& stopLine);
  explicit TrafficLight(const RegulatoryElementDataPtr& data);
};
 
enum class ManeuverType {
  Yield,       
  RightOfWay,  
  Unknown      
};
 
class RightOfWay : public RegulatoryElement {
 public:
  using Ptr = std::shared_ptr<RightOfWay>;
  static constexpr char RuleName[] = "right_of_way";
 
  static Ptr make(Id id, const AttributeMap& attributes, const Lanelets& rightOfWay, const Lanelets& yield,
                  const Optional<LineString3d>& stopLine = {}) {
    return Ptr{new RightOfWay(id, attributes, rightOfWay, yield, stopLine)};
  }
 
  ManeuverType getManeuver(const ConstLanelet& lanelet) const;
 
  ConstLanelets rightOfWayLanelets() const;
  Lanelets rightOfWayLanelets();
 
  ConstLanelets yieldLanelets() const;
  Lanelets yieldLanelets();
 
  Optional<ConstLineString3d> stopLine() const;
  Optional<LineString3d> stopLine();
 
  void setStopLine(const LineString3d& stopLine);
 
  void addRightOfWayLanelet(const Lanelet& lanelet);
 
  void addYieldLanelet(const Lanelet& lanelet);
 
  bool removeRightOfWayLanelet(const Lanelet& lanelet);
 
  bool removeYieldLanelet(const Lanelet& lanelet);
 
  void removeStopLine();
 
 protected:
  friend class RegisterRegulatoryElement<RightOfWay>;
  RightOfWay(Id id, const AttributeMap& attributes, const Lanelets& rightOfWay, const Lanelets& yield,
             const Optional<LineString3d>& stopLine = {});
  explicit RightOfWay(const RegulatoryElementDataPtr& data);
};
 
struct LaneletWithStopLine {
  Lanelet lanelet;
  Optional<LineString3d> stopLine;
};
struct ConstLaneletWithStopLine {
  ConstLanelet lanelet;
  Optional<ConstLineString3d> stopLine;
};
using LaneletsWithStopLines = std::vector<LaneletWithStopLine>;
 
class AllWayStop : public RegulatoryElement {
 public:
  using Ptr = std::shared_ptr<AllWayStop>;
  static constexpr char RuleName[] = "all_way_stop";
 
  static Ptr make(Id id, const AttributeMap& attributes, const LaneletsWithStopLines& lltsWithStop,
                  const LineStringsOrPolygons3d& signs = {}) {
    return Ptr{new AllWayStop(id, attributes, lltsWithStop, signs)};
  }
 
  ConstLanelets lanelets() const;
  Lanelets lanelets();
 
  void addLanelet(const LaneletWithStopLine& lltWithStop);
 
  bool removeLanelet(const Lanelet& llt);
 
  ConstLineStrings3d stopLines() const;
  LineStrings3d stopLines();
 
  Optional<ConstLineString3d> getStopLine(const ConstLanelet& llt) const;
  Optional<LineString3d> getStopLine(const ConstLanelet& llt);
 
  ConstLineStringsOrPolygons3d trafficSigns() const;
  LineStringsOrPolygons3d trafficSigns();
 
 
  void addTrafficSign(const LineStringOrPolygon3d& sign);
 
  bool removeTrafficSign(const LineStringOrPolygon3d& sign);
 
 protected:
  friend class RegisterRegulatoryElement<AllWayStop>;
  AllWayStop(Id id, const AttributeMap& attributes, const LaneletsWithStopLines& lltsWithStop,
             const LineStringsOrPolygons3d& signs);
  explicit AllWayStop(const RegulatoryElementDataPtr& data);
};
 
struct TrafficSignsWithType {
  LineStringsOrPolygons3d trafficSigns;  
  std::string type{""};                  
};
 
class TrafficSign : public RegulatoryElement {
 public:
  using Ptr = std::shared_ptr<TrafficSign>;
  static constexpr char RuleName[] = "traffic_sign";
 
  static Ptr make(Id id, const AttributeMap& attributes, const TrafficSignsWithType& trafficSigns,
                  const TrafficSignsWithType& cancellingTrafficSigns = {}, const LineStrings3d& refLines = {},
                  const LineStrings3d& cancelLines = {}) {
    return Ptr(new TrafficSign(id, attributes, trafficSigns, cancellingTrafficSigns, refLines, cancelLines));
  }
 
 
  ConstLineStringsOrPolygons3d trafficSigns() const;
  LineStringsOrPolygons3d trafficSigns();
 
 
  std::string type() const;
 
 
  ConstLineStrings3d refLines() const;
  LineStrings3d refLines();
 
  ConstLineStringsOrPolygons3d cancellingTrafficSigns() const;
  LineStringsOrPolygons3d cancellingTrafficSigns();
 
  std::vector<std::string> cancelTypes() const;
 
  ConstLineStrings3d cancelLines() const;
  LineStrings3d cancelLines();
 
 
  void addTrafficSign(const LineStringOrPolygon3d& sign);
 
  bool removeTrafficSign(const LineStringOrPolygon3d& sign);
 
  void addCancellingTrafficSign(const TrafficSignsWithType& signs);
 
  bool removeCancellingTrafficSign(const LineStringOrPolygon3d& sign);
 
  void addRefLine(const LineString3d& line);
 
  bool removeRefLine(const LineString3d& line);
 
  void addCancellingRefLine(const LineString3d& line);
 
  bool removeCancellingRefLine(const LineString3d& line);
 
 protected:
  TrafficSign(Id id, const AttributeMap& attributes, const TrafficSignsWithType& trafficSigns,
              const TrafficSignsWithType& cancellingTrafficSigns = {}, const LineStrings3d& refLines = {},
              const LineStrings3d& cancelLines = {});
 
  friend class RegisterRegulatoryElement<TrafficSign>;
  explicit TrafficSign(const RegulatoryElementDataPtr& data);
};
 
class SpeedLimit : public TrafficSign {
 public:
  using Ptr = std::shared_ptr<SpeedLimit>;
  static constexpr char RuleName[] = "speed_limit";
 
  static Ptr make(Id id, const AttributeMap& attributes, const TrafficSignsWithType& trafficSigns,
                  const TrafficSignsWithType& cancellingTrafficSigns = {}, const LineStrings3d& refLines = {},
                  const LineStrings3d& cancelLines = {}) {
    return Ptr(new SpeedLimit(id, attributes, trafficSigns, cancellingTrafficSigns, refLines, cancelLines));
  }
 
  static Ptr make(Id id, AttributeMap attributes, const std::string& signType, const LineStrings3d& refLines = {},
                  const LineStrings3d& cancelLines = {}) {
    attributes.insert(std::make_pair(AttributeNamesString::SignType, signType));
    return Ptr(new SpeedLimit(id, attributes, {}, {}, refLines, cancelLines));
  }
 
 protected:
  friend class RegisterRegulatoryElement<SpeedLimit>;
  SpeedLimit(Id id, const AttributeMap& attributes, const TrafficSignsWithType& trafficSigns,
             const TrafficSignsWithType& cancellingTrafficSigns = {}, const LineStrings3d& refLines = {},
             const LineStrings3d& cancelLines = {});
  explicit SpeedLimit(const RegulatoryElementDataPtr& data);
};
}  // namespace lanelet