mesh.hpp

#pragma once

#include "sparse_point_cloud.hpp"
#include "dense_point_cloud.hpp"
#include "sparse_components_pointers_3d.hpp"
#include "polygon_3d.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS

template <class T>
class Mesh final
{
  struct PrivateTag{};

  public:
    Mesh(const SparsePointCloudPtr& pointCloud, PrivateTag)
      : pointCloud_(pointCloud)
    {
      CVB_CALL_CAPI_CHECKED(CVC3DPointCloudGetPolygonTable(pointCloud_->Handle(), polygonTable_, numPolygons_));
      components_ = pointCloud_->PointComponents<T>();
    }

    Mesh(const Mesh&) = delete;
    Mesh& operator=(const Mesh&) = delete;


    static MeshPtr<T> FromFile(const String& fileName)
    {
      // TODO get flags
      auto pointCloud =  Internal::DoResCallShareOut<SparsePointCloud>([&](void*& handle)
        {
          return CVB_CALL_CAPI(CVC3DLoadFileTyped(fileName.c_str(), static_cast<CExports::cvbval_t>(PointTypeAsFlags()), handle));
        });
      return std::make_shared<Mesh<T>>(pointCloud, PrivateTag{});
    }


    static MeshPtr<T> FromPointCloud(const SparsePointCloudPtr& pointCloud)
    {
      auto pMesh = std::make_shared<Mesh<T>>(pointCloud, PrivateTag{});
      if(!pMesh)
        throw std::runtime_error("could not create mesh from point cloud");

      return pMesh;
    }


    std::size_t NumPolygons() const noexcept
    {
      return static_cast<std::size_t>(numPolygons_);
    }


    Polygon3D<T> PolygonAt(std::size_t index) const
    {
      auto ptr = IndexTablePtrAt(index);
      std::vector<T> points;
      std::generate_n(std::back_inserter(points), *ptr, [this, ptr,  i = 0]() mutable
      {
        ++i;
        return components_.PointAt(*(ptr + i));
      });
      return { std::move(points) };
    }


    std::vector<std::uint32_t> PolygonIndicesAt(std::size_t index) const
    {
      auto ptr = IndexTablePtrAt(index);
      std::vector<std::uint32_t> indices;
      std::generate_n(std::back_inserter(indices), *ptr, [ptr, i = 0]() mutable
          {
            ++i;
            return *(ptr + i);
          });
      return indices;
    }


    std::size_t NumPoints() const noexcept
    {
      return components_.NumPoints();
    }


    T PointAt(std::size_t index) const noexcept
    {
      return components_.PointAt(index);
    }


    Cuboid CalculateBoundingBox() const
    {
      return pointCloud_->CalculateBoundingBox();
    }


    void RasterDensePointCloudToDst(const Matrix3D& cameraRotation, Vector3D<double> cameraTranslation, DensePointCloud& denseCloud)
    {
      CVB_CALL_CAPI_CHECKED(CVC3DRasterMeshToDensePointCloud(pointCloud_->Handle(),
        *reinterpret_cast<const CExports::CVC3DMatrix*>(&cameraRotation),
        *reinterpret_cast<CExports::CVC3DVector*>(&cameraTranslation),
        nullptr,
        denseCloud.Handle()));
    }


    DensePointCloudPtr RasterDensePointCloud(const Matrix3D& cameraRotation, Vector3D<double> cameraTranslation, double xResIncrement, double yResIncrement)
    {
      return Internal::DoResCallShareOut<DensePointCloud>([&](void*& handle)
        {
          return CVB_CALL_CAPI(CVC3DCreateRasterMeshToDensePointCloud(pointCloud_->Handle(),
            *reinterpret_cast<const CExports::CVC3DMatrix*>(&cameraRotation),
            *reinterpret_cast<CExports::CVC3DVector*>(&cameraTranslation),
            xResIncrement,
            yResIncrement,
            nullptr,
            handle));
        });
    }

  private:

    CExports::cvbuint32_t* IndexTablePtrAt(std::size_t index) const noexcept
    {
      auto ptr = polygonTable_;
      for (std::size_t i = 0; i < index; ++i)
        ptr = IncrementTablePtr(ptr);
      return ptr;
    }

    static CExports::cvbuint32_t* IncrementTablePtr(CExports::cvbuint32_t* ptr) noexcept
    {
      return ptr + *ptr + 1;
    }

    static PointCloudFlags PointTypeAsFlags() noexcept;

    SparsePointCloudPtr pointCloud_;
    SparseComponentsPointers3D<T> components_;
    CExports::cvbuint32_t* polygonTable_ = nullptr;
    CExports::cvbint64_t numPolygons_ = 0;

};

template<>
inline Cvb::PointCloudFlags Mesh<Cvb::Point3D<float>>::PointTypeAsFlags() noexcept
{
  return Cvb::PointCloudFlags::Float | Cvb::PointCloudFlags::XYZ;
}

template<>
inline Cvb::PointCloudFlags Mesh<Cvb::Point3DH<float>>::PointTypeAsFlags() noexcept
{
  return Cvb::PointCloudFlags::Float | Cvb::PointCloudFlags::XYZW;
}

template<>
inline Cvb::PointCloudFlags Mesh<Cvb::Point3D<double>>::PointTypeAsFlags() noexcept
{
  return Cvb::PointCloudFlags::Double | Cvb::PointCloudFlags::XYZ;
}

template<>
inline Cvb::PointCloudFlags Mesh<Cvb::Point3DH<double>>::PointTypeAsFlags() noexcept
{
  return Cvb::PointCloudFlags::Double | Cvb::PointCloudFlags::XYZW;
}


CVB_END_INLINE_NS

}