decl_plane_enumerator.hpp

#pragma once
 
#include <algorithm>
 
#include "../_decl/decl_point_cloud.hpp"
 
#include "../plane.hpp"
#include "../global.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<PlaneEnumerator>::HandleGuard(void *handle) noexcept
      : HandleGuard<PlaneEnumerator>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }


  class PlaneEnumerator final
  {
    struct PrivateTag
    {
    };
 
  public:
    using GuardType = HandleGuard<PlaneEnumerator>;


    PlaneEnumerator() noexcept
        : handle_(nullptr)
    {
      planes_.resize(PlaneCount());
    }
    PlaneEnumerator() noexcept {…}


    PlaneEnumerator(HandleGuard<PlaneEnumerator> &&guard, PrivateTag) noexcept
        : handle_(std::move(guard))
    {
      planes_.resize(PlaneCount());
    }
    PlaneEnumerator(HandleGuard<PlaneEnumerator> &&guard, PrivateTag) noexcept {…}


    template <class T>
    static PlaneEnumerator FromObject(const T &object);


    static PlaneEnumeratorPtr FromHandle(HandleGuard<PlaneEnumerator> &&guard)
    {
      if (!guard.Handle() || CVB_CALL_CAPI(CVCIsComposite(guard.Handle())))
        throw std::runtime_error("handle must not be null and object must not be a composite");
 
      return std::make_shared<PlaneEnumerator>(std::move(guard), PrivateTag{});
    }
    static PlaneEnumeratorPtr FromHandle(HandleGuard<PlaneEnumerator> &&guard) {…}
 
    template <class T>
    static PlaneEnumeratorPtr FromHandle(HandleGuard<PlaneEnumerator> &&guard)
    {
      static_assert(std::is_base_of<PlaneEnumerator, T>::value, "CVB: Type must be derived from PlaneEnumerator");
      return FromHandle(std::move(guard));
    }


    void *Handle() const noexcept
    {
      return handle_.Handle();
    }
    void *Handle() const noexcept {…}


    int PlaneCount() const noexcept
    {
      CExports::cvbdim_t numPlanes = 0;
      CVB_CALL_CAPI(CVCPlaneEnumGetCount(Handle(), numPlanes));
      return static_cast<int>(numPlanes);
    }
    int PlaneCount() const noexcept {…}


    std::vector<PlanePtr> Planes() const
    {
      std::vector<PlanePtr> planes;
      std::generate_n(std::back_inserter(planes), PlaneCount(), [this, i = 0]() mutable { return Plane(i++); });
      return planes;
    }
    std::vector<PlanePtr> Planes() const {…}


    PlanePtr operator[](int index) const
    {
      return Plane(index);
    }
    PlanePtr operator[](int index) const {…}


    PlanePtr Plane(int index) const
    {
      if (index < 0 || index >= PlaneCount())
        throw std::length_error("index out of range");
 
      if (auto plane = planes_[index].lock())
        return plane;
 
      CExports::CVPLANE handle = nullptr;
      CVB_CALL_CAPI_CHECKED(CVCPlaneEnumGetAt(Handle(), static_cast<CExports::cvbdim_t>(index), handle));
      auto plane     = Plane::FromHandle(HandleGuard<class Plane>(handle));
      planes_[index] = plane;
      return plane;
    }
    PlanePtr Plane(int index) const {…}
 
  private:
    mutable std::vector<std::weak_ptr<class Plane>> planes_;
 
    HandleGuard<PlaneEnumerator> handle_;
  };
  class PlaneEnumerator final {…};
 
  CVB_END_INLINE_NS
}  // namespace Cvb