ImplicitGridT.hh

//=============================================================================
//
//  CLASS ImplicitGrid
//
//=============================================================================


#ifndef ISOEX_IMPLICITGRID_HH
#define ISOEX_IMPLICITGRID_HH


//== INCLUDES =================================================================

#include <IsoEx/Grids/RegularGridT.hh>
#include <IsoEx/Implicits/Implicit.hh>
#include <OpenMesh/Core/Geometry/VectorT.hh>
#include <vector>

//== NAMESPACES ===============================================================

namespace IsoEx {

//== CLASS DEFINITION =========================================================

              
template <class Vec3 >
class ImplicitGrid : public RegularGrid< Vec3 >
{
public:
   
  typedef typename Vec3::value_type real;

  typedef typename Grid< Vec3 >::CubeIdx CubeIdx;

  typedef typename Grid< Vec3 >::PointIdx PointIdx;

  //------------------------------------------------------------ public methods


  ImplicitGrid(const Implicit<Vec3>& _implicit,
               const Vec3&  _origin,
               const Vec3&  _x_axis,
               const Vec3&  _y_axis,
               const Vec3&  _z_axis,
               unsigned int            _x_res,
               unsigned int            _y_res,
               unsigned int            _z_res) 
    : RegularGrid< Vec3 >(_origin, _x_axis, _y_axis, _z_axis, _x_res, _y_res, _z_res),
      implicit_(_implicit) 
  {}

  virtual ~ImplicitGrid() {}





  virtual bool is_inside(PointIdx _pidx) const {
    return (is_inside_cache_.empty() ? implicit_.is_inside(this->point(_pidx)) : is_inside_cache_[_pidx]);
  }

  virtual real scalar_distance(PointIdx _pidx) const {
    return (scalar_distance_cache_.empty() ? implicit_.scalar_distance(this->point(_pidx)) : scalar_distance_cache_[_pidx]);
  }

  virtual bool directed_distance(const Vec3&  _p0,
                                 const Vec3&  _p1,
                                 Vec3&        _point,
                                 Vec3&        _normal,
                                 real&       _distance) const {
    return implicit_.directed_distance(_p0, _p1, _point, _normal, _distance);
  }
  





  void build_is_inside_cache() const
  {
    int i, np( this->n_points() );
    
    is_inside_cache_.clear();
    is_inside_cache_.resize( this->n_points());

    for (i=0; i<np; ++i)
      is_inside_cache_[i] = implicit_.is_inside(this->point(i));
  }

  void build_scalar_distance_cache() const
  {
    int i, np(this->n_points());

    scalar_distance_cache_.clear();
    scalar_distance_cache_.resize(np);

    for (i=0; i<np; ++i)
      scalar_distance_cache_[i] = implicit_.scalar_distance(this->point(i));
  }



 
protected:

  const Implicit<Vec3>&     implicit_;

  mutable std::vector<bool>   is_inside_cache_;
  mutable std::vector<real>  scalar_distance_cache_;
};


//=============================================================================
} // namespace IsoEx
//=============================================================================
#endif // ISOEX_IMPLICITGRID_HH defined
//=============================================================================