primitives/Area.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; c-basic-offset: 2;
// indent-tabs-mode: nil -*-

#pragma once

#include <memory>
#include <utility>

#include "lanelet2_core/Forward.h"
#include "lanelet2_core/primitives/CompoundPolygon.h"
#include "lanelet2_core/primitives/Point.h"
#include "lanelet2_core/primitives/Polygon.h"
#include "lanelet2_core/primitives/Primitive.h"
#include "lanelet2_core/utility/Optional.h"

namespace lanelet {

using InnerBounds = std::vector<LineStrings3d>;
using ConstInnerBounds = std::vector<ConstLineStrings3d>;

class AreaData : public PrimitiveData {
 public:
  AreaData(Id id, LineStrings3d outerBound, std::vector<LineStrings3d> innerBounds = std::vector<LineStrings3d>(),
           AttributeMap attributes = AttributeMap(), RegulatoryElementPtrs regulatoryElements = RegulatoryElementPtrs())
      : PrimitiveData(id, std::move(attributes)),
        outerBound_{std::move(outerBound)},
        innerBounds_{std::move(innerBounds)},
        regulatoryElements_{std::move(regulatoryElements)} {
    resetCache();
  }

  ConstLineStrings3d outerBound() const {
    return utils::transform(outerBound_, [](const auto& elem) { return ConstLineString3d(elem); });
  }
  ConstInnerBounds innerBounds() const {
    return utils::transform(innerBounds_, [](const auto& elem) {
      return utils::transform(elem, [](const auto& ls) { return ConstLineString3d(ls); });
    });
  }
  const LineStrings3d& outerBound() { return outerBound_; }
  const InnerBounds& innerBounds() { return innerBounds_; }

  const CompoundPolygon3d& outerBoundPolygon() const { return outerBoundPolygon_; }

  const CompoundPolygons3d& innerBoundPolygons() const { return innerBoundPolygons_; }

  RegulatoryElementConstPtrs regulatoryElements() const {
    return utils::transform(regulatoryElements_, [](const auto& elem) { return RegulatoryElementConstPtr(elem); });
  }
  RegulatoryElementPtrs& regulatoryElements() { return regulatoryElements_; }

  template <typename RegElemT>
  std::vector<std::shared_ptr<const RegElemT>> regulatoryElementsAs() const {
    return utils::transformSharedPtr<const RegElemT>(regulatoryElements_);
  }
  template <typename RegElemT>
  std::vector<std::shared_ptr<RegElemT>> regulatoryElementsAs() {
    return utils::transformSharedPtr<RegElemT>(regulatoryElements_);
  }

  void setOuterBound(const LineStrings3d& bound) {
    outerBound_ = bound;
    resetCache();
  }

  void setInnerBounds(const std::vector<LineStrings3d>& bounds) {
    innerBounds_ = bounds;
    resetCache();
  }

  void resetCache() {
    outerBoundPolygon_ = CompoundPolygon3d(utils::addConst(*this).outerBound());
    innerBoundPolygons_ = utils::transform(utils::addConst(*this).innerBounds(),
                                           [](const auto& elem) { return CompoundPolygon3d(elem); });
  }

 private:
  LineStrings3d outerBound_;                  
  std::vector<LineStrings3d> innerBounds_;    
  RegulatoryElementPtrs regulatoryElements_;  

  // caches
  CompoundPolygon3d outerBoundPolygon_;    
  CompoundPolygons3d innerBoundPolygons_;  
};

class ConstArea : public ConstPrimitive<AreaData> {
 public:
  using ConstType = ConstArea;
  using MutableType = Area;
  using TwoDType = ConstArea;
  using ThreeDType = ConstArea;
  using Category = traits::AreaTag;

  explicit ConstArea(Id id = InvalId) : ConstArea(std::make_shared<AreaData>(id, LineStrings3d())) {}

  ConstArea(Id id, const LineStrings3d& outerBound, const InnerBounds& innerBounds = InnerBounds(),
            const AttributeMap& attributes = AttributeMap(),
            const RegulatoryElementPtrs& regulatoryElements = RegulatoryElementPtrs())
      : ConstPrimitive{std::make_shared<AreaData>(id, outerBound, innerBounds, attributes, regulatoryElements)} {}

  explicit ConstArea(const std::shared_ptr<const AreaData>& data) : ConstPrimitive<AreaData>(data) {}

  ConstLineStrings3d outerBound() const { return constData()->outerBound(); }

  ConstInnerBounds innerBounds() const { return constData()->innerBounds(); }

  CompoundPolygon3d outerBoundPolygon() const { return constData()->outerBoundPolygon(); }

  CompoundPolygons3d innerBoundPolygons() const { return constData()->innerBoundPolygons(); }

  BasicPolygonWithHoles3d basicPolygonWithHoles3d() const {
    return {outerBoundPolygon().basicPolygon(),
            utils::transform(innerBoundPolygons(), [](const auto& poly) { return poly.basicPolygon(); })};
  }

  BasicPolygonWithHoles2d basicPolygonWithHoles2d() const {
    return {traits::to2D(outerBoundPolygon()).basicPolygon(),
            utils::transform(innerBoundPolygons(), [](const auto& poly) { return traits::to2D(poly).basicPolygon(); })};
  }

  RegulatoryElementConstPtrs regulatoryElements() const { return constData()->regulatoryElements(); }

  template <typename RegElemT>
  std::vector<std::shared_ptr<const RegElemT>> regulatoryElementsAs() const {
    return constData()->regulatoryElementsAs<RegElemT>();
  }
};

class Area : public Primitive<ConstArea> {
 public:
  using Primitive::Primitive;
  using TwoDType = Area;
  using ThreeDType = Area;
  friend class ConstWeakArea;
  Area() = default;
  Area(const AreaDataConstPtr&) = delete;
  explicit Area(const AreaDataPtr& data) : Primitive{data} {}

  using Primitive::innerBounds;
  using Primitive::outerBound;
  using Primitive::regulatoryElements;
  using Primitive::regulatoryElementsAs;

  const LineStrings3d& outerBound() { return data()->outerBound(); }

  const InnerBounds& innerBounds() { return data()->innerBounds(); }

  void setOuterBound(const LineStrings3d& bound) { data()->setOuterBound(bound); }

  void setInnerBounds(const std::vector<LineStrings3d>& bounds) { data()->setInnerBounds(bounds); }

  const RegulatoryElementPtrs& regulatoryElements() { return data()->regulatoryElements(); }

  void addRegulatoryElement(RegulatoryElementPtr regElem) {
    if (regElem == nullptr) {
      throw NullptrError("regulatory element is a nullptr.");
    }
    data()->regulatoryElements().push_back(std::move(regElem));
  }

  bool removeRegulatoryElement(const RegulatoryElementPtr& regElem) {
    auto& regElems = data()->regulatoryElements();
    auto remove = std::find(regElems.begin(), regElems.end(), regElem);
    if (remove != regElems.end()) {
      regElems.erase(remove);
      return true;
    }
    return false;
  }

  template <typename RegElemT>
  std::vector<std::shared_ptr<RegElemT>> regulatoryElementsAs() {
    return data()->regulatoryElementsAs<RegElemT>();
  }
};

class ConstWeakArea {
 public:
  using ConstType = ConstWeakArea;
  using MutableType = WeakArea;
  using TwoDType = ConstWeakArea;
  using ThreeDType = ConstWeakArea;
  ConstWeakArea() = default;
  ConstWeakArea(ConstArea area)  // NOLINT
      : areaData_(area.constData()) {}

  ConstArea lock() const { return ConstArea(areaData_.lock()); }

  bool expired() const noexcept { return areaData_.expired(); }

 protected:
  std::weak_ptr<const AreaData> areaData_;  // NOLINT
};

class WeakArea final : public ConstWeakArea {
 public:
  WeakArea() = default;
  WeakArea(Area llet) : ConstWeakArea(std::move(llet)) {}  // NOLINT

  Area lock() const { return Area(std::const_pointer_cast<AreaData>(areaData_.lock())); }
};

namespace utils {
inline bool has(const ConstArea& ll, Id id) { return has(ll.outerBoundPolygon(), id); }
}  // namespace utils

inline bool operator==(const ConstArea& lhs, const ConstArea& rhs) { return lhs.constData() == rhs.constData(); }
inline bool operator!=(const ConstArea& lhs, const ConstArea& rhs) { return !(lhs == rhs); }
inline bool operator==(const ConstWeakArea& lhs, const ConstWeakArea& rhs) {
  return !lhs.expired() && !rhs.expired() && lhs.lock() == rhs.lock();
}
inline bool operator!=(const ConstWeakArea& lhs, const ConstWeakArea& rhs) { return !(lhs == rhs); }
inline std::ostream& operator<<(std::ostream& stream, const ConstArea& obj) {
  stream << "[id: ";
  stream << obj.id();
  auto obId = obj.outerBoundPolygon().ids();
  if (!obId.empty()) {
    stream << " outer: [";
    std::copy(obId.begin(), obId.end(), std::ostream_iterator<Id>(stream, ","));
    stream << "]";
  }
  auto ibs = obj.innerBoundPolygons();
  if (!ibs.empty()) {
    stream << " inner: ";
    for (const auto& ib : ibs) {
      stream << "[";
      auto ibId = ib.ids();
      std::copy(ibId.begin(), ibId.end(), std::ostream_iterator<Id>(stream, ","));
      stream << "]";
    }
  }
  stream << "]";
  return stream;
}

namespace traits {
template <typename T>
constexpr bool isAreaT() {
  return isCategory<T, traits::AreaTag>();
}
}  // namespace traits

template <typename T, typename RetT>
using IfAr = std::enable_if_t<traits::isAreaT<T>(), RetT>;

}  // namespace lanelet

// Hash function for usage in containers
namespace std {
template <>
struct hash<lanelet::Area> : public lanelet::HashBase<lanelet::Area> {};
template <>
struct hash<lanelet::ConstArea> : public lanelet::HashBase<lanelet::ConstArea> {};
}  // namespace std