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