MeshVoxelizer.h

 
#pragma once
 
#if !defined MeshVoxelizer_h
#define MeshVoxelizer_h
 
// Inclusions
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/shapes/Mesh.h"
#include "DGtal/shapes/IntersectionTarget.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/kernel/sets/CDigitalSet.h"
#include "DGtal/geometry/tools/determinant/PredicateFromOrientationFunctor2.h"
#include "DGtal/geometry/tools/determinant/InHalfPlaneBySimple3x3Matrix.h"
 
namespace DGtal
{
 
 
  template <typename TDigitalSet, int Separation = 6>
  class MeshVoxelizer
  {
 
  public:
 
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSet<TDigitalSet> ));
 
    typedef TDigitalSet DigitalSet;
    BOOST_STATIC_ASSERT_MSG( DigitalSet::Space::dimension == 3, "DigitalSet dimension must be 3");
 
    BOOST_STATIC_ASSERT_MSG( Separation == 6 || Separation == 26, "Separation must be 6 or 26");
 
    /****** Associated types *********************/
    using Space = typename DigitalSet::Space;
    using Space2D = SpaceND<2, typename Space::Integer>;
    using MeshFace = std::vector< unsigned int >;
    using Domain   = typename DigitalSet::Domain;
    using PointR3  = typename Space::RealPoint;
    using VectorR3 = typename Space::RealPoint;
    using PointR2  = typename Space2D::RealPoint;
    using PointZ3  = typename Space::Point;
    using OrientationFunctor = InHalfPlaneBySimple3x3Matrix<PointR2, double>;
    using IntersectionTarget = typename IntersectionTargetTrait<Space, Separation, 1>::Type;
    /*********************************************/
 
  public:
 
    MeshVoxelizer() = default;
 
    // ----------------------- Standard services ------------------------------
    template<typename MeshPoint>
    void voxelize(DigitalSet &outputSet,
                  const Mesh<MeshPoint> &aMesh,
                  const double scaleFactor = 1.0);
 
    template<typename MeshPoint>
    void voxelize(DigitalSet &outputSet,
                  const MeshPoint &a, const MeshPoint &b, const MeshPoint &c,
                  const double scaleFactor = 1.0);
 
 
 
    // ----------------------- Internal services ------------------------------
    enum TriangleOrientation { OUTSIDE, INSIDE, ONEDGE, ONVERTEX };
 
    static
    double distance(const PointR3& M,
                    const VectorR3& n,
                    const PointZ3& p) ;
 
    static
    TriangleOrientation pointIsInside2DTriangle(const PointR2& A,
                                                const PointR2& B,
                                                const PointR2& C,
                                                const PointR2& p) ;
 
    static
    bool pointIsInsideVoxel(const PointR3& P,
                            const PointZ3& v) ;
 
    void voxelizeTriangle(DigitalSet &outputSet,
                          const PointR3& A,
                          const PointR3& B,
                          const PointR3& C,
                          const VectorR3& n,
                          const std::pair<PointZ3, PointZ3>& bbox);
 
    // ----------------------- Members ------------------------------
 
  private:
 
    IntersectionTarget myIntersectionTarget;
  };
}
 
// Includes inline functions.
#include "DGtal/shapes/MeshVoxelizer.ih"
 
//                                                                           //
 
#endif // !defined MeshVoxelizer_h