igl::WindingNumberAABB< Point, DerivedV, DerivedF > Class Template Reference

#include <src/libigl/igl/WindingNumberAABB.h>

Inheritance diagram for igl::WindingNumberAABB< Point, DerivedV, DerivedF >:

Collaboration diagram for igl::WindingNumberAABB< Point, DerivedV, DerivedF >:

Public Types
enum	SplitMethod { CENTER_ON_LONGEST_AXIS = 0 , MEDIAN_ON_LONGEST_AXIS = 1 , NUM_SPLIT_METHODS = 2 }

Public Member Functions
	WindingNumberAABB ()
	WindingNumberAABB (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedF > &F)
	WindingNumberAABB (const WindingNumberTree< Point, DerivedV, DerivedF > &parent, const Eigen::MatrixBase< DerivedF > &F)
void	set_mesh (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedF > &F)
void	init ()
bool	inside (const Point &p) const
virtual void	grow ()
void	compute_min_max_corners ()
DerivedV::Scalar	max_abs_winding_number (const Point &p) const
DerivedV::Scalar	max_simple_abs_winding_number (const Point &p) const
void	delete_children ()
void	set_method (const WindingNumberMethod &m)
const DerivedV &	getV () const
const MatrixXF &	getF () const
const MatrixXF &	getcap () const
DerivedV::Scalar	winding_number (const Point &p) const
DerivedV::Scalar	winding_number_all (const Point &p) const
DerivedV::Scalar	winding_number_boundary (const Point &p) const
void	print (const char *tab="")
virtual DerivedV::Scalar	cached_winding_number (const WindingNumberTree &that, const Point &p) const

Public Attributes
enum igl::WindingNumberAABB::SplitMethod	split_method

Static Public Attributes
static std::map< std::pair< const WindingNumberTree *, const WindingNumberTree * >, typename DerivedV::Scalar >	cached
static DerivedV	dummyV

Protected Types
typedef Eigen::Matrix< typename DerivedV::Scalar, Eigen::Dynamic, Eigen::Dynamic >	MatrixXS
typedef Eigen::Matrix< typename DerivedF::Scalar, Eigen::Dynamic, Eigen::Dynamic >	MatrixXF

Protected Attributes
Point	min_corner
Point	max_corner
DerivedV::Scalar	total_positive_area
WindingNumberMethod	method
const WindingNumberTree *	parent
std::list< WindingNumberTree * >	children
DerivedV &	V
MatrixXS	SV
MatrixXF	F
MatrixXF	cap
DerivedV::Scalar	radius
Point	center

Detailed Description

template<typename Point, typename DerivedV, typename DerivedF>
class igl::WindingNumberAABB< Point, DerivedV, DerivedF >

Member Typedef Documentation

MatrixXF

template<typename Point , typename DerivedV , typename DerivedF >

typedef Eigen::Matrix<typename DerivedF::Scalar,Eigen::Dynamic,Eigen::Dynamic> igl::WindingNumberTree< Point, DerivedV, DerivedF >::MatrixXF

protectedinherited

MatrixXS

template<typename Point , typename DerivedV , typename DerivedF >

typedef Eigen::Matrix<typename DerivedV::Scalar,Eigen::Dynamic,Eigen::Dynamic> igl::WindingNumberTree< Point, DerivedV, DerivedF >::MatrixXS

protectedinherited

Member Enumeration Documentation

SplitMethod

template<typename Point , typename DerivedV , typename DerivedF >

enum igl::WindingNumberAABB::SplitMethod

Enumerator
CENTER_ON_LONGEST_AXIS
MEDIAN_ON_LONGEST_AXIS
NUM_SPLIT_METHODS

      {
        CENTER_ON_LONGEST_AXIS = 0,
        MEDIAN_ON_LONGEST_AXIS = 1,
        NUM_SPLIT_METHODS = 2
      } split_method;

Constructor & Destructor Documentation

WindingNumberAABB() [1/3]

template<typename Point , typename DerivedV , typename DerivedF >

igl::WindingNumberAABB< Point, DerivedV, DerivedF >::WindingNumberAABB ( )

inline

                                :
        total_positive_area(std::numeric_limits<typename DerivedV::Scalar>::infinity()),
        split_method(MEDIAN_ON_LONGEST_AXIS)
      {}

WindingNumberAABB() [2/3]

template<typename Point , typename DerivedV , typename DerivedF >

igl::WindingNumberAABB< Point, DerivedV, DerivedF >::WindingNumberAABB ( const Eigen::MatrixBase< DerivedV > &  V, const Eigen::MatrixBase< DerivedF > &  F  )

inline

                                      :
  WindingNumberTree<Point,DerivedV,DerivedF>(V,F),
  min_corner(),
  max_corner(),
  total_positive_area(
    std::numeric_limits<typename DerivedV::Scalar>::infinity()),
  split_method(MEDIAN_ON_LONGEST_AXIS)
{
  init();
}

References igl::WindingNumberAABB< Point, DerivedV, DerivedF >::init().

Here is the call graph for this function:

WindingNumberAABB() [3/3]

template<typename Point , typename DerivedV , typename DerivedF >

igl::WindingNumberAABB< Point, DerivedV, DerivedF >::WindingNumberAABB ( const WindingNumberTree< Point, DerivedV, DerivedF > &  parent, const Eigen::MatrixBase< DerivedF > &  F  )

inline

                                      :
  WindingNumberTree<Point,DerivedV,DerivedF>(parent,F),
  min_corner(),
  max_corner(),
  total_positive_area(
    std::numeric_limits<typename DerivedV::Scalar>::infinity()),
  split_method(MEDIAN_ON_LONGEST_AXIS)
{
  init();
}

References igl::WindingNumberAABB< Point, DerivedV, DerivedF >::init().

Here is the call graph for this function:

Member Function Documentation

cached_winding_number()

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV::Scalar igl::WindingNumberTree< Point, DerivedV, DerivedF >::cached_winding_number ( const WindingNumberTree< Point, DerivedV, DerivedF > &  that, const Point &  p  ) const

inlinevirtualinherited

{
  using namespace std;
  // Simple metric for `is_far`
  //
  //   this             that
  //                   --------
  //   -----          /   |    \ .
  //  /  r  \        /    R     \ .
  // | p !   |      |     !      |
  //  \_____/        \          /
  //                  \________/
  //
  // 
  // a = angle formed by trapazoid formed by raising sides with lengths r and R
  // at respective centers.
  //
  // a = atan2(R-r,d), where d is the distance between centers
 
  // That should be bigger (what about parent? what about sister?)
  bool is_far = this->radius<that.radius;
  if(is_far)
  {
    typename DerivedV::Scalar a = atan2(
      that.radius - this->radius,
      (that.center - this->center).norm());
    assert(a>0);
    is_far = (a<PI/8.0);
  }
 
  if(is_far)
  {
    // Not implemented yet
    pair<const WindingNumberTree*,const WindingNumberTree*> this_that(this,&that);
    // Need to compute it for first time?
    if(cached.count(this_that)==0)
    {
      cached[this_that] = 
        that.winding_number_boundary(this->center);
    }
    return cached[this_that];
  }else if(children.size() == 0)
  {
    // not far and hierarchy ended too soon: can't use cache
    return that.winding_number_boundary(p);
  }else
  {
    for(
      typename list<WindingNumberTree<Point,DerivedV,DerivedF>* >::const_iterator cit = children.begin();
      cit != children.end();
      cit++)
    {
      if((*cit)->inside(p))
      {
        return (*cit)->cached_winding_number(that,p);
      }
    }
    // Not inside any children? This can totally happen because bounding boxes
    // are set to bound contained facets. So sibilings may overlap and their
    // union may not contain their parent (though, their union is certainly a
    // subset of their parent).
    assert(false);
  }
  return 0;
}

References igl::WindingNumberTree< Point, DerivedV, DerivedF >::center, igl::PI, igl::WindingNumberTree< Point, DerivedV, DerivedF >::radius, and igl::WindingNumberTree< Point, DerivedV, DerivedF >::winding_number_boundary().

Here is the call graph for this function:

compute_min_max_corners()

template<typename Point , typename DerivedV , typename DerivedF >

void igl::WindingNumberAABB< Point, DerivedV, DerivedF >::compute_min_max_corners

inline

{
  using namespace std;
  // initialize corners
  for(int d = 0;d<min_corner.size();d++)
  {
    min_corner[d] =  numeric_limits<typename Point::Scalar>::infinity();
    max_corner[d] = -numeric_limits<typename Point::Scalar>::infinity();
  }
 
  this->center = Point(0,0,0);
  // Loop over facets
  for(int i = 0;i<this->getF().rows();i++)
  {
    for(int j = 0;j<this->getF().cols();j++)
    {
      for(int d = 0;d<min_corner.size();d++)
      {
        min_corner[d] = 
          this->getV()(this->getF()(i,j),d) < min_corner[d] ?  
            this->getV()(this->getF()(i,j),d) : min_corner[d];
        max_corner[d] = 
          this->getV()(this->getF()(i,j),d) > max_corner[d] ?  
            this->getV()(this->getF()(i,j),d) : max_corner[d];
      }
      // This is biased toward vertices incident on more than one face, but
      // perhaps that's good
      this->center += this->getV().row(this->getF()(i,j));
    }
  }
  // Average
  this->center.array() /= this->getF().size();
 
  //cout<<"min_corner: "<<this->min_corner.transpose()<<endl;
  //cout<<"Center: "<<this->center.transpose()<<endl;
  //cout<<"max_corner: "<<this->max_corner.transpose()<<endl;
  //cout<<"Diag center: "<<((this->max_corner + this->min_corner)*0.5).transpose()<<endl;
  //cout<<endl;
 
  this->radius = (max_corner-min_corner).norm()/2.0;
}

delete_children()

template<typename Point , typename DerivedV , typename DerivedF >

void igl::WindingNumberTree< Point, DerivedV, DerivedF >::delete_children

inlineinherited

{
  using namespace std;
  // Delete children
  typename list<WindingNumberTree<Point,DerivedV,DerivedF>* >::iterator cit = children.begin();
  while(cit != children.end())
  {
    // clear the memory of this item
    delete (* cit);
    // erase from list, returns next element in iterator
    cit = children.erase(cit);
  }
}

getcap()

template<typename Point , typename DerivedV , typename DerivedF >

const igl::WindingNumberTree< Point, DerivedV, DerivedF >::MatrixXF & igl::WindingNumberTree< Point, DerivedV, DerivedF >::getcap

inlineinherited

{
  return cap;
}

getF()

template<typename Point , typename DerivedV , typename DerivedF >

const igl::WindingNumberTree< Point, DerivedV, DerivedF >::MatrixXF & igl::WindingNumberTree< Point, DerivedV, DerivedF >::getF

inlineinherited

{
  return F;
}

getV()

template<typename Point , typename DerivedV , typename DerivedF >

const DerivedV & igl::WindingNumberTree< Point, DerivedV, DerivedF >::getV

inlineinherited

{
  return V;
}

grow()

template<typename Point , typename DerivedV , typename DerivedF >

void igl::WindingNumberAABB< Point, DerivedV, DerivedF >::grow

inlinevirtual

Reimplemented from igl::WindingNumberTree< Point, DerivedV, DerivedF >.

{
  using namespace std;
  using namespace Eigen;
  // Clear anything that already exists
  this->delete_children();
 
  //cout<<"cap.rows(): "<<this->getcap().rows()<<endl;
  //cout<<"F.rows(): "<<this->getF().rows()<<endl;
 
  // Base cases
  if(
    this->getF().rows() <= (WindingNumberAABB_MIN_F>0?WindingNumberAABB_MIN_F:0) ||
    (this->getcap().rows() - 2) >= this->getF().rows())
  {
    // Don't grow
    return;
  }
 
  // Compute longest direction
  int max_d = -1;
  typename DerivedV::Scalar max_len = 
    -numeric_limits<typename DerivedV::Scalar>::infinity();
  for(int d = 0;d<min_corner.size();d++)
  {
    if( (max_corner[d] - min_corner[d]) > max_len )
    {
      max_len = (max_corner[d] - min_corner[d]);
      max_d = d;
    }
  }
  // Compute facet barycenters
  Eigen::Matrix<typename DerivedV::Scalar,Eigen::Dynamic,Eigen::Dynamic> BC;
  barycenter(this->getV(),this->getF(),BC);
 
 
  // Blerg, why is selecting rows so difficult
 
  typename DerivedV::Scalar split_value;
  // Split in longest direction
  switch(split_method)
  {
    case MEDIAN_ON_LONGEST_AXIS:
      // Determine median
      median(BC.col(max_d),split_value);
      break;
    default:
      assert(false);
    case CENTER_ON_LONGEST_AXIS:
      split_value = 0.5*(max_corner[max_d] + min_corner[max_d]);
      break;
  }
  //cout<<"c: "<<0.5*(max_corner[max_d] + min_corner[max_d])<<" "<<
  //  "m: "<<split_value<<endl;;
 
  vector<int> id( this->getF().rows());
  for(int i = 0;i<this->getF().rows();i++)
  {
    if(BC(i,max_d) <= split_value)
    {
      id[i] = 0; //left
    }else
    {
      id[i] = 1; //right
    }
  }
 
  const int lefts = (int) count(id.begin(),id.end(),0);
  const int rights = (int) count(id.begin(),id.end(),1);
  if(lefts == 0 || rights == 0)
  {
    // badly balanced base case (could try to recut)
    return;
  }
  assert(lefts+rights == this->getF().rows());
  DerivedF leftF(lefts,  this->getF().cols());
  DerivedF rightF(rights,this->getF().cols());
  int left_i = 0;
  int right_i = 0;
  for(int i = 0;i<this->getF().rows();i++)
  {
    if(id[i] == 0)
    {
      leftF.row(left_i++) = this->getF().row(i);
    }else if(id[i] == 1)
    {
      rightF.row(right_i++) = this->getF().row(i);
    }else
    {
      assert(false);
    }
  }
  assert(right_i == rightF.rows());
  assert(left_i == leftF.rows());
  // Finally actually grow children and Recursively grow
  WindingNumberAABB<Point,DerivedV,DerivedF> * leftWindingNumberAABB = 
    new WindingNumberAABB<Point,DerivedV,DerivedF>(*this,leftF);
  leftWindingNumberAABB->grow();
  this->children.push_back(leftWindingNumberAABB);
  WindingNumberAABB<Point,DerivedV,DerivedF> * rightWindingNumberAABB = 
    new WindingNumberAABB<Point,DerivedV,DerivedF>(*this,rightF);
  rightWindingNumberAABB->grow();
  this->children.push_back(rightWindingNumberAABB);
}

References igl::barycenter(), igl::count(), igl::WindingNumberAABB< Point, DerivedV, DerivedF >::grow(), and igl::median().

Referenced by igl::WindingNumberAABB< Point, DerivedV, DerivedF >::grow(), igl::signed_distance(), and igl::copyleft::cgal::signed_distance_isosurface().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

template<typename Point , typename DerivedV , typename DerivedF >

void igl::WindingNumberAABB< Point, DerivedV, DerivedF >::init

inline

{
  using namespace Eigen;
  assert(max_corner.size() == 3);
  assert(min_corner.size() == 3);
  compute_min_max_corners();
  Eigen::Matrix<typename DerivedV::Scalar,Eigen::Dynamic,1> dblA;
  doublearea(this->getV(),this->getF(),dblA);
  total_positive_area = dblA.sum()/2.0;
}

References igl::doublearea().

Referenced by igl::WindingNumberAABB< Point, DerivedV, DerivedF >::WindingNumberAABB(), and igl::WindingNumberAABB< Point, DerivedV, DerivedF >::WindingNumberAABB().

Here is the call graph for this function:

Here is the caller graph for this function:

inside()

template<typename Point , typename DerivedV , typename DerivedF >

bool igl::WindingNumberAABB< Point, DerivedV, DerivedF >::inside ( const Point &  p ) const

inlinevirtual

Reimplemented from igl::WindingNumberTree< Point, DerivedV, DerivedF >.

{
  assert(p.size() == max_corner.size());
  assert(p.size() == min_corner.size());
  for(int i = 0;i<p.size();i++)
  {
    //if( p(i) < min_corner(i) || p(i) >= max_corner(i))
    // **MUST** be conservative
    if( p(i) < min_corner(i) || p(i) > max_corner(i))
    {
      return false;
    }
  }
  return true;
}

max_abs_winding_number()

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV::Scalar igl::WindingNumberAABB< Point, DerivedV, DerivedF >::max_abs_winding_number ( const Point &  p ) const

inlinevirtual

Reimplemented from igl::WindingNumberTree< Point, DerivedV, DerivedF >.

{
  using namespace std;
  // Only valid if not inside
  if(inside(p))
  {
    return numeric_limits<typename DerivedV::Scalar>::infinity();
  }
  // Q: we know the total positive area so what's the most this could project
  // to? Remember it could be layered in the same direction.
  return numeric_limits<typename DerivedV::Scalar>::infinity();
}

max_simple_abs_winding_number()

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV::Scalar igl::WindingNumberAABB< Point, DerivedV, DerivedF >::max_simple_abs_winding_number ( const Point &  p ) const

inlinevirtual

Reimplemented from igl::WindingNumberTree< Point, DerivedV, DerivedF >.

{
  using namespace std;
  using namespace Eigen;
  // Only valid if not inside
  if(inside(p))
  {
    return numeric_limits<typename DerivedV::Scalar>::infinity();
  }
  // Max simple is the same as sum of positive winding number contributions of
  // bounding box
 
  // begin precomputation
  //MatrixXd BV((int)pow(2,3),3);
  typedef
    Eigen::Matrix<typename DerivedV::Scalar,Eigen::Dynamic,Eigen::Dynamic>
    MatrixXS;
  typedef
    Eigen::Matrix<typename DerivedF::Scalar,Eigen::Dynamic,Eigen::Dynamic>
    MatrixXF;
  MatrixXS BV((int)(1<<3),3);
  BV <<
    min_corner[0],min_corner[1],min_corner[2],
    min_corner[0],min_corner[1],max_corner[2],
    min_corner[0],max_corner[1],min_corner[2],
    min_corner[0],max_corner[1],max_corner[2],
    max_corner[0],min_corner[1],min_corner[2],
    max_corner[0],min_corner[1],max_corner[2],
    max_corner[0],max_corner[1],min_corner[2],
    max_corner[0],max_corner[1],max_corner[2];
  MatrixXF BF(2*2*3,3);
  BF <<
    0,6,4,
    0,2,6,
    0,3,2,
    0,1,3,
    2,7,6,
    2,3,7,
    4,6,7,
    4,7,5,
    0,4,5,
    0,5,1,
    1,5,7,
    1,7,3;
  MatrixXS BFN;
  per_face_normals(BV,BF,BFN);
  // end of precomputation
 
  // Only keep those with positive dot products
  MatrixXF PBF(BF.rows(),BF.cols());
  int pbfi = 0;
  Point p2c = 0.5*(min_corner+max_corner)-p;
  for(int i = 0;i<BFN.rows();i++)
  {
    if(p2c.dot(BFN.row(i)) > 0)
    {
      PBF.row(pbfi++) = BF.row(i);
    }
  }
  PBF.conservativeResize(pbfi,PBF.cols());
  return igl::winding_number(BV,PBF,p);
}

References Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::conservativeResize(), igl::per_face_normals(), Eigen::PlainObjectBase< Derived >::rows(), and igl::winding_number().

Here is the call graph for this function:

print()

template<typename Point , typename DerivedV , typename DerivedF >

void igl::WindingNumberTree< Point, DerivedV, DerivedF >::print ( const char *  tab = "" )

inlineinherited

{
  using namespace std;
  // Print all facets
  cout<<tab<<"["<<endl<<F<<endl<<"]";
  // Print children
  for(
      typename list<WindingNumberTree<Point,DerivedV,DerivedF>* >::iterator cit = children.begin();
      cit != children.end();
      cit++)
  {
    cout<<","<<endl;
    (*cit)->print((string(tab)+"").c_str());
  }
}

set_mesh()

template<typename Point , typename DerivedV , typename DerivedF >

void igl::WindingNumberAABB< Point, DerivedV, DerivedF >::set_mesh ( const Eigen::MatrixBase< DerivedV > &  V, const Eigen::MatrixBase< DerivedF > &  F  )

inlinevirtual

Reimplemented from igl::WindingNumberTree< Point, DerivedV, DerivedF >.

{
  igl::WindingNumberTree<Point,DerivedV,DerivedF>::set_mesh(V,F);
  init();
}

References igl::WindingNumberTree< Point, DerivedV, DerivedF >::set_mesh().

Referenced by igl::signed_distance(), and igl::copyleft::cgal::signed_distance_isosurface().

Here is the call graph for this function:

Here is the caller graph for this function:

set_method()

template<typename Point , typename DerivedV , typename DerivedF >

void igl::WindingNumberTree< Point, DerivedV, DerivedF >::set_method ( const WindingNumberMethod &  m )

inlineinherited

{
  this->method = m;
  for(auto child : children)
  {
    child->set_method(m);
  }
}

winding_number()

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV::Scalar igl::WindingNumberTree< Point, DerivedV, DerivedF >::winding_number ( const Point &  p ) const

inlineinherited

{
  using namespace std;
  //cout<<"+"<<boundary.rows();
  // If inside then we need to be careful
  if(inside(p))
  {
    // If not a leaf then recurse
    if(children.size()>0)
    {
      // Recurse on each child and accumulate
      typename DerivedV::Scalar sum = 0;
      for(
        typename list<WindingNumberTree<Point,DerivedV,DerivedF>* >::const_iterator cit = children.begin();
        cit != children.end();
        cit++)
      {
        switch(method)
        {
          case EXACT_WINDING_NUMBER_METHOD:
            sum += (*cit)->winding_number(p);
            break;
          case APPROX_SIMPLE_WINDING_NUMBER_METHOD:
          case APPROX_CACHE_WINDING_NUMBER_METHOD:
            //if((*cit)->max_simple_abs_winding_number(p) > min_max_w)
            //{
              sum += (*cit)->winding_number(p);
            //}
            break;
          default:
            assert(false);
            break;
        }
      }
      return sum;
    }else
    {
      return winding_number_all(p);
    }
  }else{
    // Otherwise we can just consider boundary
    // Q: If we using the "multipole" method should we also subdivide the
    // boundary case?
    if((cap.rows() - 2) < F.rows())
    {
      switch(method)
      {
        case EXACT_WINDING_NUMBER_METHOD:
          return winding_number_boundary(p);
        case APPROX_SIMPLE_WINDING_NUMBER_METHOD:
        {
          typename DerivedV::Scalar dist = (p-center).norm();
          // Radius is already an overestimate of inside
          if(dist>1.0*radius)
          {
            return 0;
          }else
          {
            return winding_number_boundary(p);
          }
        }
        case APPROX_CACHE_WINDING_NUMBER_METHOD:
        {
          return parent->cached_winding_number(*this,p);
        }
        default: assert(false);break;
      }
    }else
    {
      // doesn't pay off to use boundary
      return winding_number_all(p);
    }
  }
  return 0;
}

References igl::APPROX_CACHE_WINDING_NUMBER_METHOD, igl::APPROX_SIMPLE_WINDING_NUMBER_METHOD, igl::EXACT_WINDING_NUMBER_METHOD, and igl::sum().

Referenced by igl::signed_distance(), and igl::signed_distance_winding_number().

Here is the call graph for this function:

Here is the caller graph for this function:

winding_number_all()

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV::Scalar igl::WindingNumberTree< Point, DerivedV, DerivedF >::winding_number_all ( const Point &  p ) const

inlineinherited

{
  return igl::winding_number(V,F,p);
}

References igl::winding_number().

Here is the call graph for this function:

winding_number_boundary()

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV::Scalar igl::WindingNumberTree< Point, DerivedV, DerivedF >::winding_number_boundary ( const Point &  p ) const

inlineinherited

{
  using namespace Eigen;
  using namespace std;
  return igl::winding_number(V,cap,p);
}

References igl::winding_number().

Referenced by igl::WindingNumberTree< Point, DerivedV, DerivedF >::cached_winding_number().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cached

template<typename Point , typename DerivedV , typename DerivedF >

std::map< std::pair< const igl::WindingNumberTree< Point, DerivedV, DerivedF > *, const igl::WindingNumberTree< Point, DerivedV, DerivedF > * >, typename DerivedV::Scalar > igl::WindingNumberTree< Point, DerivedV, DerivedF >::cached

staticinherited

cap

template<typename Point , typename DerivedV , typename DerivedF >

MatrixXF igl::WindingNumberTree< Point, DerivedV, DerivedF >::cap

protectedinherited

center

template<typename Point , typename DerivedV , typename DerivedF >

Point igl::WindingNumberTree< Point, DerivedV, DerivedF >::center

protectedinherited

Referenced by igl::WindingNumberTree< Point, DerivedV, DerivedF >::cached_winding_number().

children

template<typename Point , typename DerivedV , typename DerivedF >

std::list<WindingNumberTree * > igl::WindingNumberTree< Point, DerivedV, DerivedF >::children

protectedinherited

dummyV

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV igl::WindingNumberTree< Point, DerivedV, DerivedF >::dummyV

staticinherited

F

template<typename Point , typename DerivedV , typename DerivedF >

MatrixXF igl::WindingNumberTree< Point, DerivedV, DerivedF >::F

protectedinherited

max_corner

template<typename Point , typename DerivedV , typename DerivedF >

Point igl::WindingNumberAABB< Point, DerivedV, DerivedF >::max_corner

protected

method

template<typename Point , typename DerivedV , typename DerivedF >

WindingNumberMethod igl::WindingNumberTree< Point, DerivedV, DerivedF >::method

protectedinherited

min_corner

template<typename Point , typename DerivedV , typename DerivedF >

Point igl::WindingNumberAABB< Point, DerivedV, DerivedF >::min_corner

protected

parent

template<typename Point , typename DerivedV , typename DerivedF >

const WindingNumberTree* igl::WindingNumberTree< Point, DerivedV, DerivedF >::parent

protectedinherited

radius

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV::Scalar igl::WindingNumberTree< Point, DerivedV, DerivedF >::radius

protectedinherited

Referenced by igl::WindingNumberTree< Point, DerivedV, DerivedF >::cached_winding_number().

split_method

template<typename Point , typename DerivedV , typename DerivedF >

enum igl::WindingNumberAABB::SplitMethod igl::WindingNumberAABB< Point, DerivedV, DerivedF >::split_method

SV

template<typename Point , typename DerivedV , typename DerivedF >

MatrixXS igl::WindingNumberTree< Point, DerivedV, DerivedF >::SV

protectedinherited

total_positive_area

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV::Scalar igl::WindingNumberAABB< Point, DerivedV, DerivedF >::total_positive_area

protected

V

template<typename Point , typename DerivedV , typename DerivedF >

DerivedV& igl::WindingNumberTree< Point, DerivedV, DerivedF >::V

protectedinherited

---

The documentation for this class was generated from the following file:

• src/libigl/igl/WindingNumberAABB.h