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)
        , components_(pointCloud->PointComponents<T>())
    {
      CVB_CALL_CAPI_CHECKED(CVC3DPointCloudGetPolygonTable(pointCloud_->Handle(), polygonTable_, numPolygons_));
    }
 
    Mesh(const Mesh &)                     = delete;
    Mesh &operator=(const Mesh &) noexcept = delete;
    Mesh(Mesh &&) noexcept                 = default;
    Mesh &operator=(Mesh &&)               = default;
    ~Mesh()                                = default;


    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> FromFile(const String &fileName) {…}


    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;
    }
    static MeshPtr<T> FromPointCloud(const SparsePointCloudPtr &pointCloud) {…}


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


    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 Polygon3D<T>{std::move(points)};
    }
    Polygon3D<T> PolygonAt(std::size_t index) const {…}


    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::vector<std::uint32_t> PolygonIndicesAt(std::size_t index) const {…}


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


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


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


    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()));
    }
    void RasterDensePointCloudToDst(const Matrix3D &cameraRotation, Vector3D<double> cameraTranslation, {…}


    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));
      });
    }
    DensePointCloudPtr RasterDensePointCloud(const Matrix3D &cameraRotation, Vector3D<double> cameraTranslation, {…}
 
  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;
  };
  class Mesh final {…};
 
  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
 
}  // namespace Cvb