primitives/Polygon.h

Go to the documentation of this file.

#pragma once

#include "lanelet2_core/Forward.h"
#include "lanelet2_core/primitives/LineString.h"
#include "lanelet2_core/primitives/Traits.h"

namespace lanelet {

class BasicPolygon2d : public BasicLineString2d {
 public:
  explicit BasicPolygon2d(const BasicLineString2d& other) : BasicLineString2d(other) {}
  using TwoDType = BasicPolygon2d;
  using ThreeDType = BasicPolygon3d;
  using HybridType = BasicPolygon2d;
  using PointType = BasicPoint2d;
  using BasicLineString2d::BasicLineString2d;
  BasicPolygon2d() = default;
};

class BasicPolygon3d : public BasicLineString3d {
 public:
  explicit BasicPolygon3d(const BasicLineString3d& other) : BasicLineString3d(other) {}
  using TwoDType = BasicPolygon2d;
  using ThreeDType = BasicPolygon3d;
  using HybridType = BasicPolygon3d;
  using PointType = BasicPoint3d;
  using BasicLineString3d::BasicLineString3d;
  BasicPolygon3d() = default;
};


class ConstPolygon2d : public ConstLineStringImpl<Point2d> {
 public:
  using ConstLineStringImpl::ConstLineStringImpl;
  using ConstType = ConstPolygon2d;
  using MutableType = Polygon2d;
  using TwoDType = ConstPolygon2d;
  using ThreeDType = ConstPolygon3d;
  using Category = traits::PolygonTag;
  using HybridType = ConstHybridPolygon2d;

  explicit ConstPolygon2d(const ConstLineString2d& other) : ConstLineStringImpl(other) {}
  explicit operator ConstLineString2d() const { return ConstLineString2d(constData(), inverted()); }

  ConstPolygon2d() = default;

  BasicPolygon2d basicPolygon() const { return {basicBegin(), basicEnd()}; }

  operator BasicPolygon2d() const {  // NOLINT
    return {basicBegin(), basicEnd()};
  }

  size_t numSegments() const noexcept { return size() < 2 ? 0 : size(); }
};

class ConstPolygon3d : public ConstLineStringImpl<Point3d> {
 public:
  using ConstLineStringImpl::ConstLineStringImpl;
  using ConstType = ConstPolygon3d;
  using MutableType = Polygon3d;
  using TwoDType = ConstPolygon2d;
  using ThreeDType = ConstPolygon3d;
  using Category = traits::PolygonTag;
  using HybridType = ConstHybridPolygon3d;

  ConstPolygon3d() = default;

  explicit ConstPolygon3d(const ConstLineString3d& other) : ConstLineStringImpl(other) {}
  explicit operator ConstLineString3d() const { return ConstLineString3d(constData(), inverted()); }

  BasicPolygon3d basicPolygon() const { return {basicBegin(), basicEnd()}; }

  operator BasicPolygon3d() const {  // NOLINT
    return {basicBegin(), basicEnd()};
  }

  size_t numSegments() const noexcept { return size() < 2 ? 0 : size(); }
};

class Polygon3d : public LineStringImpl<ConstPolygon3d> {
 public:
  using LineStringImpl::LineStringImpl;
  using ConstType = ConstPolygon3d;
  using MutableType = Polygon3d;
  using TwoDType = Polygon2d;
  using ThreeDType = Polygon3d;

  Polygon3d() = default;  // gcc5 needs this

  explicit Polygon3d(const LineString3d& other) : LineStringImpl(other) {}
  explicit operator LineString3d() const { return LineString3d(data(), inverted()); }

  friend class Polygon2d;

  BasicPolygon3d basicPolygon() const { return {basicBegin(), basicEnd()}; }

  operator BasicPolygon3d() const {  // NOLINT
    return {basicBegin(), basicEnd()};
  }
};

class Polygon2d : public LineStringImpl<ConstPolygon2d> {
 public:
  using LineStringImpl::LineStringImpl;
  using ConstType = ConstPolygon2d;
  using MutableType = Polygon2d;
  using TwoDType = Polygon2d;
  using ThreeDType = Polygon3d;

  Polygon2d() = default;

  explicit Polygon2d(const LineString2d& other) : LineStringImpl(other) {}
  explicit operator LineString2d() const { return LineString2d(data(), inverted()); }

  inline BasicPolygon2d basicPolygon() const {
    BasicPolygon2d::allocator_type alloc;  // gcc produces undef refs otherwise
    return BasicPolygon2d(basicBegin(), basicEnd(), alloc);
  }
  inline operator BasicPolygon2d() const {  // NOLINT
    return BasicPolygon2d(basicBegin(), basicEnd());
  }
  friend class Polygon3d;
};

class ConstHybridPolygon3d : public ConstPolygon3d {
 public:
  using const_iterator = BasicIterator;  // NOLINT
  using iterator = BasicIterator;        // NOLINT

  using ConstPolygon3d::ConstPolygon3d;
  using ConstType = ConstHybridPolygon3d;
  using TwoDType = ConstHybridPolygon2d;
  using ThreeDType = ConstHybridPolygon3d;
  using PointType = BasicPoint3d;

  ConstHybridPolygon3d() = default;

  explicit ConstHybridPolygon3d(const ConstPolygon3d& poly) : ConstPolygon3d(poly) {}

  BasicIterator begin() const noexcept { return basicBegin(); }

  BasicIterator end() const noexcept { return basicEnd(); }

  const BasicPointType& front() const noexcept { return ConstPolygon3d::front().basicPoint(); }

  const BasicPointType& back() const noexcept { return ConstPolygon3d::back().basicPoint(); }

  const BasicPointType& operator[](size_t idx) const noexcept { return ConstPolygon3d::operator[](idx).basicPoint(); }
};

class ConstHybridPolygon2d : public ConstPolygon2d {
 public:
  using const_iterator = BasicIterator;  // NOLINT
  using iterator = BasicIterator;        // NOLINT

  using ConstPolygon2d::ConstPolygon2d;
  using ConstType = ConstHybridPolygon2d;
  using TwoDType = ConstHybridPolygon2d;
  using ThreeDType = ConstHybridPolygon3d;
  using PointType = BasicPoint2d;
  using HybridType = ConstHybridPolygon2d;

  ConstHybridPolygon2d() = default;

  explicit ConstHybridPolygon2d(const ConstPolygon2d& poly) : ConstPolygon2d(poly) {}

  BasicIterator begin() const noexcept { return basicBegin(); }

  BasicIterator end() const noexcept { return basicEnd(); }

  BasicPointType front() const noexcept { return ConstPolygon2d::front().basicPoint(); }

  BasicPointType back() const noexcept { return ConstPolygon2d::back().basicPoint(); }

  BasicPointType operator[](size_t idx) const noexcept { return ConstPolygon2d::operator[](idx).basicPoint(); }
};

class BasicPolygonWithHoles3d {
 public:
  BasicPolygon3d outer;
  BasicPolygons3d inner;
};

class BasicPolygonWithHoles2d {
 public:
  BasicPolygon2d outer;
  BasicPolygons2d inner;
};

inline std::ostream& operator<<(std::ostream& stream, const ConstPolygon2d& obj) {
  return stream << ConstLineString2d(obj);
}

inline std::ostream& operator<<(std::ostream& stream, const ConstPolygon3d& obj) {
  return stream << ConstLineString2d(obj);
}

namespace internal {

template <>
class Converter<const ConstPolygon3d> {
 public:
  template <typename T>
  const ConstPolygon3d& convert(const T& t) const {
    val_ = t;
    return val_;
  }

 private:
  mutable ConstPolygon3d val_;
};
template <>
class Converter<const ConstPolygon2d> {
 public:
  template <typename T>
  const ConstPolygon2d& convert(const T& t) const {
    val_ = t;
    return val_;
  }

 private:
  mutable ConstPolygon2d val_;
};
}  // namespace internal

namespace traits {
template <typename T>
constexpr bool isPolygonT() {
  return isCategory<T, traits::PolygonTag>();
}

template <>
struct PrimitiveTraits<BasicPolygon2d> {
  using ConstType = BasicPolygon2d;
  using MutableType = BasicPolygon2d;
  using TwoDType = BasicPolygon2d;
  using ThreeDType = BasicPolygon3d;
  using Category = PolygonTag;
};
template <>
struct PrimitiveTraits<BasicPolygon3d> {
  using ConstType = BasicPolygon3d;
  using MutableType = BasicPolygon3d;
  using TwoDType = BasicPolygon2d;
  using ThreeDType = BasicPolygon3d;
  using Category = PolygonTag;
};
template <>
inline BasicPolygon2d to2D<BasicPolygon3d>(const BasicPolygon3d& primitive) {
  BasicPolygon2d p2d(primitive.size());
  std::transform(primitive.begin(), primitive.end(), p2d.begin(), utils::to2D<BasicPoint3d>);
  return p2d;
}

template <typename PolygonT>
std::enable_if_t<traits::isPolygonT<PolygonT>(), BasicPolygon2d> toBasicPolygon2d(const PolygonT& t) {
  return traits::to2D(t).basicPolygon();
}

template <>
inline BasicPolygon2d toBasicPolygon2d<BasicPolygon2d>(const BasicPolygon2d& t) {
  return t;
}

template <>
inline BasicPolygon2d toBasicPolygon2d<BasicPolygon3d>(const BasicPolygon3d& t) {
  return traits::to2D(t);
}

inline BasicPolygon2d toBasicPolygon2d(BasicPolygon2d&& t) { return std::move(t); }

template <typename PolygonT>
std::enable_if_t<traits::isPolygonT<PolygonT>(), BasicPolygon3d> toBasicPolygon3d(const PolygonT& t) {
  return traits::to3D(t).basicPolygon();
}

template <>
inline BasicPolygon3d toBasicPolygon3d<BasicPolygon3d>(const BasicPolygon3d& t) {
  return t;
}

inline BasicPolygon3d toBasicPolygon3d(BasicPolygon3d&& t) { return std::move(t); }

}  // namespace traits
template <typename T, typename RetT>
using IfPoly = std::enable_if_t<traits::isPolygonT<T>(), RetT>;

}  // namespace lanelet

// Hash function for usage in containers
namespace std {
template <>
struct hash<lanelet::Polygon3d> : public lanelet::HashBase<lanelet::Polygon3d> {};
template <>
struct hash<lanelet::ConstPolygon3d> : public lanelet::HashBase<lanelet::ConstPolygon3d> {};
template <>
struct hash<lanelet::Polygon2d> : public lanelet::HashBase<lanelet::Polygon2d> {};
template <>
struct hash<lanelet::ConstPolygon2d> : public lanelet::HashBase<lanelet::ConstPolygon2d> {};
}  // namespace std