Mesh.h

Go to the documentation of this file.

#pragma once

#include "BarycentricPoint.h"
#include "ColorToLabelMap.h"
#include "LabelToColorMap.h"
#include "Ray.h"
#include "RayMeshIntersection.h"

#include <array>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>

namespace CortidQCT {

template <class T> class Mesh {

  static_assert(std::is_floating_point<T>::value,
                "Scalar must be a floating point type");

public:
  using Scalar = T;

  using Index = std::ptrdiff_t;

  using Size = std::size_t;

  using Label = unsigned int;

private:
  using VertexData = std::vector<Scalar>;
  using IndexData = std::vector<Index>;
  using LabelData = std::vector<Label>;
  using NormalData = VertexData;

public:

  inline Mesh() noexcept(noexcept(VertexData()) && noexcept(IndexData()) &&
                         noexcept(LabelData()) && noexcept(VertexData())) {}

  inline Mesh(std::size_t nVertices, std::size_t nTriangles) noexcept(
      noexcept(VertexData(3 * nVertices, T{0})) &&
      noexcept(IndexData(3 * nTriangles, Index{0})) &&
      noexcept(LabelData(nVertices, Label{0})) &&
      noexcept(NormalData(3 * nVertices, T{0})))
      : vertexData_(3 * nVertices, T{0}), indexData_(3 * nTriangles, Index{0}),
        labelData_(nVertices, Label{0}), normalData_(3 * nVertices, T{0}) {}

  // @}


  inline Size vertexCount() const noexcept { return vertexData_.size() / 3; }

  inline Size triangleCount() const noexcept { return indexData_.size() / 3; }

  inline bool isEmpty() const noexcept {
    return triangleCount() == 0 || vertexCount() == 0;
  }


  Mesh &loadFromFile(std::string const &meshFilename,
                     std::string const &labelFilename);

  Mesh &loadFromFile(std::string const &meshFilename,
                     ColorToLabelMap<Label, double> const &colorMap =
                         ColorToLabelMaps::defaultMap<Label, double>);

  void writeToFile(std::string const &meshFilename,
                   std::string const &labelFilename) const;

  void writeToFile(std::string const &meshFilename,
                   LabelToColorMap<double, Label> const &labelMap =
                       LabelToColorMaps::defaultMap<double, Label>) const;


  std::array<T, 3>
  cartesianRepresentation(BarycentricPoint<T, Index> const &point) const;

  template <class InputIterator, class OutputIterator>
  void cartesianRepresentation(InputIterator begin, InputIterator end,
                               OutputIterator out) const;

  inline std::vector<std::array<T, 3>> cartesianRepresentation(
      std::vector<BarycentricPoint<T, Index>> const &points) const {
    using Cartesian = std::array<T, 3>;
    std::vector<Cartesian> cartPoints(points.size());

    auto const out = reinterpret_cast<T *>(cartPoints.data());
    cartesianRepresentation(points.cbegin(), points.cend(), out);

    return cartPoints;
  }

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation"

  template <class PtIter, class AttrIter, class OutputIterator>
  void barycentricInterpolation(PtIter pointsBegin, PtIter pointsEnd,
                                AttrIter attributesBegin, OutputIterator out,
                                std::size_t attributeDimension = 1) const;
#pragma clang diagnostic pop

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation"

  template <class InputIterator, class OutputIterator>
  void rayIntersections(InputIterator raysBegin, InputIterator raysEnd,
                        OutputIterator intersectionsOut) const;

  RayMeshIntersection<T> rayIntersection(Ray<T> const &ray) const;

  void updatePerVertexNormals();

#pragma clang diagnostic pop


  Mesh<T> &upsample(std::size_t nTimes = 1);


  template <class F>
  inline auto withUnsafeVertexPointer(F &&f) const
      noexcept(noexcept(f(std::declval<const VertexData>().data()))) {
    return f(vertexData_.data());
  }

  template <class F>
  inline auto withUnsafeVertexPointer(F &&f) noexcept(
      noexcept(f(std::declval<VertexData>().data()))) {
    return f(vertexData_.data());
  }

  template <class F>
  inline auto withUnsafeIndexPointer(F &&f) const
      noexcept(noexcept(f(std::declval<const IndexData>().data()))) {
    return f(indexData_.data());
  }

  template <class F>
  inline auto withUnsafeIndexPointer(F &&f) noexcept(
      noexcept(f(std::declval<IndexData>().data()))) {
    return f(indexData_.data());
  }

  template <class F>
  inline auto withUnsafeLabelPointer(F &&f) const
      noexcept(noexcept(f(LabelData().data()))) {
    return f(labelData_.data());
  }

  template <class F>
  inline auto
  withUnsafeLabelPointer(F &&f) noexcept(noexcept(f(LabelData().data()))) {
    return f(labelData_.data());
  }

  template <class F>
  inline auto withUnsafeVertexNormalPointer(F &&f) const
      noexcept(noexcept(f(std::declval<const NormalData>().data()))) {
    return f(normalData_.data());
  }

  template <class F>
  inline auto withUnsafeVertexNormalPointer(F &&f) noexcept(
      noexcept(f(std::declval<NormalData>().data()))) {
    return f(normalData_.data());
  }

private:
  void ensurePostconditions() const;

  VertexData vertexData_;
  IndexData indexData_;
  LabelData labelData_;
  NormalData normalData_;
};

/*************************************
 * Explicit template instanciations
 */

extern template class Mesh<float>;
extern template class Mesh<double>;

extern template void Mesh<float>::barycentricInterpolation(
    BarycentricPoint<float, std::ptrdiff_t> const *,
    BarycentricPoint<float, std::ptrdiff_t> const *, float const *, float *,
    std::size_t) const;
extern template void Mesh<double>::barycentricInterpolation(
    BarycentricPoint<double, std::ptrdiff_t> const *,
    BarycentricPoint<double, std::ptrdiff_t> const *, double const *, double *,
    std::size_t) const;

extern template void Mesh<float>::cartesianRepresentation(
    BarycentricPoint<float, std::ptrdiff_t> const *,
    BarycentricPoint<float, std::ptrdiff_t> const *, float *) const;
extern template void Mesh<double>::cartesianRepresentation(
    BarycentricPoint<float, std::ptrdiff_t> const *,
    BarycentricPoint<float, std::ptrdiff_t> const *, double *) const;
extern template void Mesh<float>::cartesianRepresentation(
    std::vector<BarycentricPoint<float, std::ptrdiff_t>>::const_iterator,
    std::vector<BarycentricPoint<float, std::ptrdiff_t>>::const_iterator,
    float *) const;
extern template void Mesh<double>::cartesianRepresentation(
    std::vector<BarycentricPoint<double, std::ptrdiff_t>>::const_iterator,
    std::vector<BarycentricPoint<double, std::ptrdiff_t>>::const_iterator,
    double *) const;

extern template void
Mesh<float>::rayIntersections(Ray<float> const *, Ray<float> const *,
                              RayMeshIntersection<float> *) const;
extern template void Mesh<float>::rayIntersections(
    Ray<float> const *, Ray<float> const *,
    std::back_insert_iterator<std::vector<RayMeshIntersection<float>>>) const;
extern template void
Mesh<double>::rayIntersections(Ray<double> const *, Ray<double> const *,
                               RayMeshIntersection<double> *) const;
extern template void Mesh<double>::rayIntersections(
    Ray<double> const *, Ray<double> const *,
    std::back_insert_iterator<std::vector<RayMeshIntersection<double>>>) const;

} // namespace CortidQCT