polygon_3d.hpp

#pragma once
 
#include <vector>
 
#include "global.hpp"
 
#include "point_3d.hpp"
#include "point_3d_h.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
template <class T>
using IsPolygonPoint =
std::integral_constant<bool,
  (std::is_same<Point3D<typename T::ValueType>, T>::value || std::is_same<Point3DH<typename T::ValueType>, T>::value) 
    && std::is_floating_point<typename T::ValueType>::value>;
 
template <class T>
using EnablePolygonPoint = std::enable_if<IsPolygonPoint<T>::value>;
 
 
template<class T, class ENABLE = void>
class Polygon3D final
{
 
#ifndef CVB_DOXYGEN
  static_assert (IsPolygonPoint<T>::value, "CVB: Polygon type must be Point3D or Point3DH with floating point type");
};
 
 
template <class T>
class Polygon3D<T,
  typename EnablePolygonPoint<T>::type> final
{
 
#endif
 
  public:
 
 
    Polygon3D() = default;
 
    Polygon3D(const Polygon3D&) = default;
 
    Polygon3D& operator=(const Polygon3D&) = default;
 
    ~Polygon3D() = default;
 
 
    explicit Polygon3D(std::vector<T>&& points)
      : points_(std::move(points))
    {
    }
 
    Polygon3D(Polygon3D&&) = default;
    Polygon3D& operator=(Polygon3D&&) = default;
 
 
    explicit Polygon3D(const std::vector<T>& points) noexcept
      : points_(points)
    {
    }
 
 
    template<std::size_t N>
    Polygon3D(const T(&list)[N]) noexcept // NOLINT
    {
      static_assert(N >= 3, "CVB: Poligon3D must have at least three points");
      points_ = std::vector<T>(list, list + N); // NOLINT(cppcoreguidelines-prefer-member-initializer)
    }
 
 
    const T& operator[](std::size_t index) const noexcept
    {
      return points_[index];
    }
 
 
    const T& At(std::size_t index) const
    {
      return points_.at(index);
    }
 
 
    std::size_t NumPoints() const noexcept
    {
      return points_.size();
    }
 
 
    auto CBegin() const noexcept
    {
      return points_.cbegin();
    }
 
 
    auto Begin() const noexcept
    {
      return CBegin();
    }
 
 
    auto cbegin() const noexcept
    {
      return CBegin();
    }
 
 
    auto begin() const noexcept
    {
      return CBegin();
    }
 
 
    auto CEnd() const noexcept
    {
      return points_.cend();
    }
 
 
    auto End() const noexcept
    {
      return CEnd();
    }
 
 
    auto cend() const noexcept
    {
      return CEnd();
    }
 
 
    auto end() const noexcept
    {
      return cend();
    }
 
 
    auto CRBegin() const noexcept
    {
      return points_.crbegin();
    }
 
 
    auto RBegin() const noexcept
    {
      return CRBegin();
    }
 
 
    auto crbegin() const noexcept
    {
      return CRBegin();
    }
 
 
    auto rbegin() const noexcept
    {
      return crbegin();
    }
 
 
    auto CREnd() const noexcept
    {
      return points_.crend();
    }
 
 
    auto REnd() const noexcept
    {
      return CREnd();
    }
 
 
    auto crend() const noexcept
    {
      return CREnd();
    }
 
 
    auto rend() const noexcept
    {
      return crend();
    }
 
 
    bool operator==(const Polygon3D<T>& polygon) const noexcept
    {
      return points_ == polygon.points_;
    }
 
 
 
    bool operator!=(const Polygon3D<T>& polygon) const noexcept
    {
      return !(*this == polygon);
    }
 
    template <class C>
    explicit operator Polygon3D<C>() const noexcept
    {
      std::vector<C> points;
      points.reserve(points_.size());
      for (const auto& point : points_)
        points.emplace_back(static_cast<C>(point));
      return Polygon3D<C>(std::move(points));
    }
 
  private:
 
    std::vector<T> points_;
 
 
 
};
 
CVB_END_INLINE_NS
 
 
}