igl::embree Namespace Reference

Classes
class	EmbreeIntersector

Functions
template<typename DerivedP , typename DerivedN , typename DerivedS >
IGL_INLINE void	ambient_occlusion (const EmbreeIntersector &ei, const Eigen::PlainObjectBase< DerivedP > &P, const Eigen::PlainObjectBase< DerivedN > &N, const int num_samples, Eigen::PlainObjectBase< DerivedS > &S)
template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedN , typename DerivedS >
IGL_INLINE void	ambient_occlusion (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedP > &P, const Eigen::PlainObjectBase< DerivedN > &N, const int num_samples, Eigen::PlainObjectBase< DerivedS > &S)
IGL_INLINE bool	bone_heat (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const Eigen::MatrixXd &C, const Eigen::VectorXi &P, const Eigen::MatrixXi &BE, const Eigen::MatrixXi &CE, Eigen::MatrixXd &W)
template<typename DerivedV , typename DerivedF , typename DerivedSD , typename Derivedflag >
IGL_INLINE void	bone_visible (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedSD > &s, const Eigen::PlainObjectBase< DerivedSD > &d, Eigen::PlainObjectBase< Derivedflag > &flag)
template<typename DerivedV , typename DerivedF , typename DerivedSD , typename Derivedflag >
IGL_INLINE void	bone_visible (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const EmbreeIntersector &ei, const Eigen::PlainObjectBase< DerivedSD > &s, const Eigen::PlainObjectBase< DerivedSD > &d, Eigen::PlainObjectBase< Derivedflag > &flag)
template<typename ScalarMatrix , typename IndexMatrix >
IGL_INLINE ScalarMatrix	line_mesh_intersection (const ScalarMatrix &V_source, const ScalarMatrix &N_source, const ScalarMatrix &V_target, const IndexMatrix &F_target)
template<typename DerivedV , typename DerivedF , typename DerivedI , typename DerivedC >
IGL_INLINE void	reorient_facets_raycast (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, int rays_total, int rays_minimum, bool facet_wise, bool use_parity, bool is_verbose, Eigen::PlainObjectBase< DerivedI > &I, Eigen::PlainObjectBase< DerivedC > &C)
template<typename DerivedV , typename DerivedF , typename DerivedFF , typename DerivedI >
IGL_INLINE void	reorient_facets_raycast (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, Eigen::PlainObjectBase< DerivedFF > &FF, Eigen::PlainObjectBase< DerivedI > &I)
template<typename DerivedP , typename DerivedN , typename DerivedS >
IGL_INLINE void	shape_diameter_function (const EmbreeIntersector &ei, const Eigen::PlainObjectBase< DerivedP > &P, const Eigen::PlainObjectBase< DerivedN > &N, const int num_samples, Eigen::PlainObjectBase< DerivedS > &S)
template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedN , typename DerivedS >
IGL_INLINE void	shape_diameter_function (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedP > &P, const Eigen::PlainObjectBase< DerivedN > &N, const int num_samples, Eigen::PlainObjectBase< DerivedS > &S)
template<typename Derivedobj >
IGL_INLINE int	unproject_in_mesh (const Eigen::Vector2f &pos, const Eigen::Matrix4f &model, const Eigen::Matrix4f &proj, const Eigen::Vector4f &viewport, const EmbreeIntersector &ei, Eigen::PlainObjectBase< Derivedobj > &obj, std::vector< igl::Hit > &hits)
template<typename Derivedobj >
IGL_INLINE int	unproject_in_mesh (const Eigen::Vector2f &pos, const Eigen::Matrix4f &model, const Eigen::Matrix4f &proj, const Eigen::Vector4f &viewport, const EmbreeIntersector &ei, Eigen::PlainObjectBase< Derivedobj > &obj)
IGL_INLINE bool	unproject_onto_mesh (const Eigen::Vector2f &pos, const Eigen::MatrixXi &F, const Eigen::Matrix4f &model, const Eigen::Matrix4f &proj, const Eigen::Vector4f &viewport, const EmbreeIntersector &ei, int &fid, Eigen::Vector3f &bc)
IGL_INLINE bool	unproject_onto_mesh (const Eigen::Vector2f &pos, const Eigen::MatrixXi &F, const Eigen::Matrix4f &model, const Eigen::Matrix4f &proj, const Eigen::Vector4f &viewport, const EmbreeIntersector &ei, int &fid, int &vid)

Variables
static bool	EmbreeIntersector_inited = false

Function Documentation

ambient_occlusion() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedN , typename DerivedS >

IGL_INLINE void igl::embree::ambient_occlusion	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const Eigen::PlainObjectBase< DerivedN > &	N,
		const int	num_samples,
		Eigen::PlainObjectBase< DerivedS > &	S
	)

{
  using namespace Eigen;
  EmbreeIntersector ei;
  ei.init(V.template cast<float>(),F.template cast<int>());
  ambient_occlusion(ei,P,N,num_samples,S);
}

References igl::ambient_occlusion(), and igl::embree::EmbreeIntersector::init().

Here is the call graph for this function:

ambient_occlusion() [2/2]

template<typename DerivedP , typename DerivedN , typename DerivedS >

IGL_INLINE void igl::embree::ambient_occlusion	(	const EmbreeIntersector &	ei,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const Eigen::PlainObjectBase< DerivedN > &	N,
		const int	num_samples,
		Eigen::PlainObjectBase< DerivedS > &	S
	)

{
  const auto & shoot_ray = [&ei](
    const Eigen::Vector3f& s,
    const Eigen::Vector3f& dir)->bool
  {
    igl::Hit hit;
    const float tnear = 1e-4f;
    return ei.intersectRay(s,dir,hit,tnear);
  };
  return igl::ambient_occlusion(shoot_ray,P,N,num_samples,S);
}

References igl::ambient_occlusion(), and igl::embree::EmbreeIntersector::intersectRay().

Here is the call graph for this function:

bone_heat()

bool igl::embree::bone_heat	(	const Eigen::MatrixXd &	V,
		const Eigen::MatrixXi &	F,
		const Eigen::MatrixXd &	C,
		const Eigen::VectorXi &	P,
		const Eigen::MatrixXi &	BE,
		const Eigen::MatrixXi &	CE,
		Eigen::MatrixXd &	W
	)

{
  using namespace std;
  using namespace Eigen;
  assert(CE.rows() == 0 && "Cage edges not supported.");
  assert(C.cols() == V.cols() && "V and C should have same #cols");
  assert(BE.cols() == 2 && "BE should have #cols=2");
  assert(F.cols() == 3 && "F should contain triangles.");
  assert(V.cols() == 3 && "V should contain 3D positions.");
 
  const int n = V.rows();
  const int np = P.rows();
  const int nb = BE.rows();
  const int m = np + nb;
 
  // "double sided lighting"
  MatrixXi FF;
  FF.resize(F.rows()*2,F.cols());
  FF << F, F.rowwise().reverse();
  // Initialize intersector
  EmbreeIntersector ei;
  ei.init(V.cast<float>(),F.cast<int>());
 
  typedef Matrix<bool,Dynamic,1> VectorXb;
  typedef Matrix<bool,Dynamic,Dynamic> MatrixXb;
  MatrixXb vis_mask(n,m);
  // Distances
  MatrixXd D(n,m);
  // loop over points
  for(int j = 0;j<np;j++)
  {
    const Vector3d p = C.row(P(j));
    D.col(j) = (V.rowwise()-p.transpose()).rowwise().norm();
    VectorXb vj;
    bone_visible(V,F,ei,p,p,vj);
    vis_mask.col(j) = vj;
  }
 
  // loop over bones
  for(int j = 0;j<nb;j++)
  {
    const Vector3d s = C.row(BE(j,0));
    const Vector3d d = C.row(BE(j,1));
    VectorXd t,sqrD;
    project_to_line_segment(V,s,d,t,sqrD);
    D.col(np+j) = sqrD.array().sqrt();
    VectorXb vj;
    bone_visible(V,F,ei,s,d,vj);
    vis_mask.col(np+j) = vj;
  }
 
  if(CE.rows() > 0)
  {
    cerr<<"Error: Cage edges are not supported. Ignored."<<endl;
  }
 
  MatrixXd PP = MatrixXd::Zero(n,m);
  VectorXd min_D;
  VectorXd Hdiag = VectorXd::Zero(n);
  VectorXi J;
  mat_min(D,2,min_D,J);
  for(int i = 0;i<n;i++)
  {
    PP(i,J(i)) = 1;
    if(vis_mask(i,J(i)))
    {
      double hii = pow(min_D(i),-2.); 
      Hdiag(i) = (hii>1e10?1e10:hii);
    }
  }
  SparseMatrix<double> Q,L,M;
  cotmatrix(V,F,L);
  massmatrix(V,F,MASSMATRIX_TYPE_DEFAULT,M);
  const auto & H = Hdiag.asDiagonal();
  Q = (-L+M*H);
  SimplicialLLT <SparseMatrix<double > > llt;
  llt.compute(Q);
  switch(llt.info())
  {
    case Eigen::Success:
      break;
    case Eigen::NumericalIssue:
      cerr<<"Error: Numerical issue."<<endl;
      return false;
    default:
      cerr<<"Error: Other."<<endl;
      return false;
  }
 
  const auto & rhs = M*H*PP;
  W = llt.solve(rhs);
  return true;
}

References bone_visible(), Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::compute(), igl::cotmatrix(), Eigen::SimplicialCholeskyBase< Derived >::info(), igl::embree::EmbreeIntersector::init(), L, igl::massmatrix(), igl::MASSMATRIX_TYPE_DEFAULT, igl::mat_min(), Eigen::NumericalIssue, igl::project_to_line_segment(), Eigen::SparseSolverBase< Derived >::solve(), and Eigen::Success.

Here is the call graph for this function:

bone_visible() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedSD , typename Derivedflag >

IGL_INLINE void igl::embree::bone_visible	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedSD > &	s,
		const Eigen::PlainObjectBase< DerivedSD > &	d,
		Eigen::PlainObjectBase< Derivedflag > &	flag
	)

{
  // "double sided lighting"
  Eigen::Matrix<typename DerivedF::Scalar,Eigen::Dynamic,Eigen::Dynamic> FF;
  FF.resize(F.rows()*2,F.cols());
  FF << F, F.rowwise().reverse();
  // Initialize intersector
  EmbreeIntersector ei;
  ei.init(V.template cast<float>(),FF.template cast<int>());
  return bone_visible(V,F,ei,s,d,flag);
}

References bone_visible(), igl::embree::EmbreeIntersector::init(), and Eigen::PlainObjectBase< Derived >::resize().

Referenced by bone_heat(), and bone_visible().

Here is the call graph for this function:

Here is the caller graph for this function:

bone_visible() [2/2]

template<typename DerivedV , typename DerivedF , typename DerivedSD , typename Derivedflag >

IGL_INLINE void igl::embree::bone_visible	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const EmbreeIntersector &	ei,
		const Eigen::PlainObjectBase< DerivedSD > &	s,
		const Eigen::PlainObjectBase< DerivedSD > &	d,
		Eigen::PlainObjectBase< Derivedflag > &	flag
	)

{
  using namespace std;
  using namespace Eigen;
  flag.resize(V.rows());
  const double sd_norm = (s-d).norm();
  // Embree seems to be parallel when constructing but not when tracing rays
#pragma omp parallel for
  // loop over mesh vertices
  for(int v = 0;v<V.rows();v++)
  {
    const Vector3d Vv = V.row(v);
    // Project vertex v onto line segment sd
    //embree.intersectSegment
    double t,sqrd;
    Vector3d projv;
    // degenerate bone, just snap to s
    if(sd_norm < DOUBLE_EPS)
    {
      t = 0;
      sqrd = (Vv-s).array().pow(2).sum();
      projv = s;
    }else
    {
      // project onto (infinite) line
      project_to_line(
        Vv(0),Vv(1),Vv(2),s(0),s(1),s(2),d(0),d(1),d(2),
        projv(0),projv(1),projv(2),t,sqrd);
      // handle projections past endpoints
      if(t<0)
      {
        t = 0;
        sqrd = (Vv-s).array().pow(2).sum();
        projv = s;
      } else if(t>1)
      {
        t = 1;
        sqrd = (Vv-d).array().pow(2).sum();
        projv = d;
      }
    }
    igl::Hit hit;
    // perhaps 1.0 should be 1.0-epsilon, or actually since we checking the
    // incident face, perhaps 1.0 should be 1.0+eps
    const Vector3d dir = (Vv-projv)*1.0;
    if(ei.intersectSegment(
       projv.template cast<float>(),
       dir.template cast<float>(), 
       hit))
    {
      // mod for double sided lighting
      const int fi = hit.id % F.rows();
 
      //if(v == 1228-1)
      //{
      //  Vector3d bc,P;
      //  bc << 1 - hit.u - hit.v, hit.u, hit.v; // barycentric
      //  P = V.row(F(fi,0))*bc(0) + 
      //      V.row(F(fi,1))*bc(1) + 
      //      V.row(F(fi,2))*bc(2);
      //  cout<<(fi+1)<<endl;
      //  cout<<bc.transpose()<<endl;
      //  cout<<P.transpose()<<endl;
      //  cout<<hit.t<<endl;
      //  cout<<(projv + dir*hit.t).transpose()<<endl;
      //  cout<<Vv.transpose()<<endl;
      //}
 
      // Assume hit is valid, so not visible
      flag(v) = false;
      // loop around corners of triangle
      for(int c = 0;c<F.cols();c++)
      {
        if(F(fi,c) == v)
        {
          // hit self, so no hits before, so vertex v is visible
          flag(v) = true;
          break;
        }
      }
      // Hit is actually past v
      if(!flag(v) && (hit.t*hit.t*dir.squaredNorm())>sqrd)
      {
        flag(v) = true;
      }
    }else
    {
      // no hit so vectex v is visible
      flag(v) = true;
    }
  }
}

References igl::DOUBLE_EPS, igl::Hit::id, igl::embree::EmbreeIntersector::intersectSegment(), igl::project_to_line(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::PlainObjectBase< Derived >::rows(), and igl::Hit::t.

Here is the call graph for this function:

line_mesh_intersection()

template<typename ScalarMatrix , typename IndexMatrix >

IGL_INLINE ScalarMatrix igl::embree::line_mesh_intersection	(	const ScalarMatrix &	V_source,
		const ScalarMatrix &	N_source,
		const ScalarMatrix &	V_target,
		const IndexMatrix &	F_target
	)

{
 
  double tol = 0.00001;
 
  Eigen::MatrixXd ray_pos = V_source;
  Eigen::MatrixXd ray_dir = N_source;
 
  // Allocate matrix for the result
  ScalarMatrix R;
  R.resize(V_source.rows(), 3);
 
  // Initialize embree
  EmbreeIntersector embree;
  embree.init(V_target.template cast<float>(),F_target.template cast<int>());
 
  // Shoot rays from the source to the target
  for (unsigned i=0; i<ray_pos.rows(); ++i)
  {
    igl::Hit A,B;
    // Shoot ray A
    Eigen::RowVector3d A_pos = ray_pos.row(i) + tol * ray_dir.row(i);
    Eigen::RowVector3d A_dir = -ray_dir.row(i);
 
    bool A_hit = embree.intersectBeam(A_pos.cast<float>(), A_dir.cast<float>(),A);
 
    Eigen::RowVector3d B_pos = ray_pos.row(i) - tol * ray_dir.row(i);
    Eigen::RowVector3d B_dir = ray_dir.row(i);
 
    bool B_hit = embree.intersectBeam(B_pos.cast<float>(), B_dir.cast<float>(),B);
 
 
    int choice = -1;
 
    if (A_hit && ! B_hit)
      choice = 0;
    else if (!A_hit && B_hit)
      choice = 1;
    else if (A_hit && B_hit)
      choice = A.t > B.t;
 
    Eigen::RowVector3d temp;
 
    if (choice == -1)
      temp << -1, 0, 0;
    else if (choice == 0)
      temp << A.id, A.u, A.v;
    else if (choice == 1)
      temp << B.id, B.u, B.v;
 
    R.row(i) = temp;
 
  }
 
  return R;
 
}

References igl::Hit::id, igl::embree::EmbreeIntersector::init(), igl::embree::EmbreeIntersector::intersectBeam(), igl::Hit::t, igl::Hit::u, and igl::Hit::v.

Here is the call graph for this function:

reorient_facets_raycast() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedFF , typename DerivedI >

IGL_INLINE void igl::embree::reorient_facets_raycast	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		Eigen::PlainObjectBase< DerivedFF > &	FF,
		Eigen::PlainObjectBase< DerivedI > &	I
	)

{
  const int rays_total = F.rows()*100;
  const int rays_minimum = 10;
  const bool facet_wise = false;
  const bool use_parity = false;
  const bool is_verbose = false;
  Eigen::VectorXi C;
  reorient_facets_raycast(
    V,F,rays_total,rays_minimum,facet_wise,use_parity,is_verbose,I,C);
  // Conservative in case FF = F
  FF.conservativeResize(F.rows(),F.cols());
  for(int i = 0;i<I.rows();i++)
  {
    if(I(i))
    {
      FF.row(i) = (F.row(i).reverse()).eval();
    }else
    {
      FF.row(i) = F.row(i);
    }
  }
}

References Eigen::PlainObjectBase< Derived >::conservativeResize(), reorient_facets_raycast(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

reorient_facets_raycast() [2/2]

template<typename DerivedV , typename DerivedF , typename DerivedI , typename DerivedC >

IGL_INLINE void igl::embree::reorient_facets_raycast	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		int	rays_total,
		int	rays_minimum,
		bool	facet_wise,
		bool	use_parity,
		bool	is_verbose,
		Eigen::PlainObjectBase< DerivedI > &	I,
		Eigen::PlainObjectBase< DerivedC > &	C
	)

{
  using namespace Eigen;
  using namespace std;
  assert(F.cols() == 3);
  assert(V.cols() == 3);
 
  // number of faces
  const int m = F.rows();
 
  MatrixXi FF = F;
  if (facet_wise) {
    C.resize(m);
    for (int i = 0; i < m; ++i) C(i) = i;
 
  } else {
    if (is_verbose) cout << "extracting patches... ";
    bfs_orient(F,FF,C);
  }
  if (is_verbose) cout << (C.maxCoeff() + 1)  << " components. ";
 
  // number of patches
  const int num_cc = C.maxCoeff()+1;
 
  // Init Embree
  EmbreeIntersector ei;
  ei.init(V.template cast<float>(),FF);
 
  // face normal
  MatrixXd N;
  per_face_normals(V,FF,N);
 
  // face area
  Matrix<typename DerivedV::Scalar,Dynamic,1> A;
  doublearea(V,FF,A);
  double area_total = A.sum();
 
  // determine number of rays per component according to its area
  VectorXd area_per_component;
  area_per_component.setZero(num_cc);
  for (int f = 0; f < m; ++f)
  {
    area_per_component(C(f)) += A(f);
  }
  VectorXi num_rays_per_component(num_cc);
  for (int c = 0; c < num_cc; ++c)
  {
    num_rays_per_component(c) = max<int>(static_cast<int>(rays_total * area_per_component(c) / area_total), rays_minimum);
  }
  rays_total = num_rays_per_component.sum();
 
  // generate all the rays
  if (is_verbose) cout << "generating rays... ";
  uniform_real_distribution<float> rdist;
  mt19937 prng;
  prng.seed(time(nullptr));
  vector<int     > ray_face;
  vector<Vector3f> ray_ori;
  vector<Vector3f> ray_dir;
  ray_face.reserve(rays_total);
  ray_ori .reserve(rays_total);
  ray_dir .reserve(rays_total);
  for (int c = 0; c < num_cc; ++c)
  {
    if (area_per_component[c] == 0)
    {
      continue;
    }
    vector<int> CF;     // set of faces per component
    vector<double> CF_area;
    for (int f = 0; f < m; ++f)
    {
      if (C(f)==c)
      {
        CF.push_back(f);
        CF_area.push_back(A(f));
      }
    }
    // discrete distribution for random selection of faces with probability proportional to their areas
    discrete_distribution<int> ddist(CF.size(), 0, CF.size(), [&](double i){ return CF_area[static_cast<int>(i)]; });       // simple ctor of (Iter, Iter) not provided by the stupid VC11/12
    for (int i = 0; i < num_rays_per_component[c]; ++i)
    {
      int f = CF[ddist(prng)];          // select face with probability proportional to face area
      float s = rdist(prng);            // random barycentric coordinate (reference: Generating Random Points in Triangles [Turk, Graphics Gems I 1990])
      float t = rdist(prng);
      float sqrt_t = sqrtf(t);
      float a = 1 - sqrt_t;
      float b = (1 - s) * sqrt_t;
      float c = s * sqrt_t;
      Vector3f p = a * V.row(FF(f,0)).template cast<float>().eval()       // be careful with the index!!!
                 + b * V.row(FF(f,1)).template cast<float>().eval()
                 + c * V.row(FF(f,2)).template cast<float>().eval();
      Vector3f n = N.row(f).cast<float>();
      if (n.isZero()) continue;
      // random direction in hemisphere around n (avoid too grazing angle)
      Vector3f d;
      while (true) {
        d = random_dir().cast<float>();
        float ndotd = n.dot(d);
        if (fabsf(ndotd) < 0.1f)
        {
          continue;
        }
        if (ndotd < 0)
        {
          d *= -1.0f;
        }
        break;
      }
      ray_face.push_back(f);
      ray_ori .push_back(p);
      ray_dir .push_back(d);
 
      if (is_verbose && ray_face.size() % (rays_total / 10) == 0) cout << ".";
    }
  }
  if (is_verbose) cout << ray_face.size()  << " rays. ";
 
  // per component voting: first=front, second=back
  vector<pair<float, float>> C_vote_distance(num_cc, make_pair(0, 0));      // sum of distance between ray origin and intersection
  vector<pair<int  , int  >> C_vote_infinity(num_cc, make_pair(0, 0));      // number of rays reaching infinity
  vector<pair<int  , int  >> C_vote_parity(num_cc, make_pair(0, 0));        // sum of parity count for each ray
 
  if (is_verbose) cout << "shooting rays... ";
#pragma omp parallel for
  for (int i = 0; i < (int)ray_face.size(); ++i)
  {
    int      f = ray_face[i];
    Vector3f o = ray_ori [i];
    Vector3f d = ray_dir [i];
    int c = C(f);
 
    // shoot ray toward front & back
    vector<Hit> hits_front;
    vector<Hit> hits_back;
    int num_rays_front;
    int num_rays_back;
    ei.intersectRay(o,  d, hits_front, num_rays_front);
    ei.intersectRay(o, -d, hits_back , num_rays_back );
    if (!hits_front.empty() && hits_front[0].id == f) hits_front.erase(hits_front.begin());
    if (!hits_back .empty() && hits_back [0].id == f) hits_back .erase(hits_back .begin());
 
    if (use_parity) {
#pragma omp atomic
      C_vote_parity[c].first  += hits_front.size() % 2;
#pragma omp atomic
      C_vote_parity[c].second += hits_back .size() % 2;
 
    } else {
      if (hits_front.empty())
      {
#pragma omp atomic
        C_vote_infinity[c].first++;
      } else {
#pragma omp atomic
        C_vote_distance[c].first += hits_front[0].t;
      }
 
      if (hits_back.empty())
      {
#pragma omp atomic
        C_vote_infinity[c].second++;
      } else {
#pragma omp atomic
        C_vote_distance[c].second += hits_back[0].t;
      }
    }
  }
 
  I.resize(m);
  for(int f = 0; f < m; ++f)
  {
    int c = C(f);
    if (use_parity) {
      I(f) = C_vote_parity[c].first > C_vote_parity[c].second ? 1 : 0;      // Ideally, parity for the front/back side should be 1/0 (i.e., parity sum for all rays should be smaller on the front side)
 
    } else {
      I(f) = (C_vote_infinity[c].first == C_vote_infinity[c].second && C_vote_distance[c].first <  C_vote_distance[c].second) ||
              C_vote_infinity[c].first <  C_vote_infinity[c].second
              ? 1 : 0;
    }
    // To account for the effect of bfs_orient
    if (F.row(f) != FF.row(f))
      I(f) = 1 - I(f);
  }
  if (is_verbose) cout << "done!" << endl;
}

References igl::bfs_orient(), Eigen::PlainObjectBase< Derived >::cols(), igl::doublearea(), igl::embree::EmbreeIntersector::init(), igl::embree::EmbreeIntersector::intersectRay(), igl::per_face_normals(), igl::random_dir(), Eigen::PlainObjectBase< Derived >::resize(), and Eigen::PlainObjectBase< Derived >::setZero().

Referenced by reorient_facets_raycast().

Here is the call graph for this function:

Here is the caller graph for this function:

shape_diameter_function() [1/2]

template<typename DerivedV , typename DerivedF , typename DerivedP , typename DerivedN , typename DerivedS >

IGL_INLINE void igl::embree::shape_diameter_function	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const Eigen::PlainObjectBase< DerivedN > &	N,
		const int	num_samples,
		Eigen::PlainObjectBase< DerivedS > &	S
	)

{
  using namespace Eigen;
  EmbreeIntersector ei;
  ei.init(V.template cast<float>(),F.template cast<int>());
  shape_diameter_function(ei,P,N,num_samples,S);
}

References igl::embree::EmbreeIntersector::init(), and shape_diameter_function().

Here is the call graph for this function:

shape_diameter_function() [2/2]

template<typename DerivedP , typename DerivedN , typename DerivedS >

IGL_INLINE void igl::embree::shape_diameter_function	(	const EmbreeIntersector &	ei,
		const Eigen::PlainObjectBase< DerivedP > &	P,
		const Eigen::PlainObjectBase< DerivedN > &	N,
		const int	num_samples,
		Eigen::PlainObjectBase< DerivedS > &	S
	)

{
  const auto & shoot_ray = [&ei](
    const Eigen::Vector3f& s,
    const Eigen::Vector3f& dir)->double
  {
    igl::Hit hit;
    const float tnear = 1e-4f;
    if(ei.intersectRay(s,dir,hit,tnear))
    {
      return hit.t;
    }else
    {
      return std::numeric_limits<double>::infinity();
    }
  };
  return igl::shape_diameter_function(shoot_ray,P,N,num_samples,S);
}

References igl::embree::EmbreeIntersector::intersectRay(), igl::shape_diameter_function(), and igl::Hit::t.

Referenced by shape_diameter_function().

Here is the call graph for this function:

Here is the caller graph for this function:

unproject_in_mesh() [1/2]

template<typename Derivedobj >

IGL_INLINE int igl::embree::unproject_in_mesh	(	const Eigen::Vector2f &	pos,
		const Eigen::Matrix4f &	model,
		const Eigen::Matrix4f &	proj,
		const Eigen::Vector4f &	viewport,
		const EmbreeIntersector &	ei,
		Eigen::PlainObjectBase< Derivedobj > &	obj
	)

{
  std::vector<igl::Hit> hits;
  return unproject_in_mesh(pos,model,proj,viewport,ei,obj,hits);
}

References unproject_in_mesh().

Here is the call graph for this function:

unproject_in_mesh() [2/2]

template<typename Derivedobj >

IGL_INLINE int igl::embree::unproject_in_mesh	(	const Eigen::Vector2f &	pos,
		const Eigen::Matrix4f &	model,
		const Eigen::Matrix4f &	proj,
		const Eigen::Vector4f &	viewport,
		const EmbreeIntersector &	ei,
		Eigen::PlainObjectBase< Derivedobj > &	obj,
		std::vector< igl::Hit > &	hits
	)

{
  using namespace std;
  using namespace Eigen;
  const auto & shoot_ray = [&ei](
    const Eigen::Vector3f& s,
    const Eigen::Vector3f& dir,
    std::vector<igl::Hit> & hits)
  {
    int num_rays_shot;
    ei.intersectRay(s,dir,hits,num_rays_shot);
  };
  return igl::unproject_in_mesh(pos,model,proj,viewport,shoot_ray,obj,hits);
}

References igl::embree::EmbreeIntersector::intersectRay(), and igl::unproject_in_mesh().

Referenced by unproject_in_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

unproject_onto_mesh() [1/2]

IGL_INLINE bool igl::embree::unproject_onto_mesh	(	const Eigen::Vector2f &	pos,
		const Eigen::MatrixXi &	F,
		const Eigen::Matrix4f &	model,
		const Eigen::Matrix4f &	proj,
		const Eigen::Vector4f &	viewport,
		const EmbreeIntersector &	ei,
		int &	fid,
		Eigen::Vector3f &	bc
	)

{
  using namespace std;
  using namespace Eigen;
  const auto & shoot_ray = [&ei](
    const Eigen::Vector3f& s,
    const Eigen::Vector3f& dir,
    igl::Hit & hit)->bool
  {
    return ei.intersectRay(s,dir,hit);
  };
  return igl::unproject_onto_mesh(pos,model,proj,viewport,shoot_ray,fid,bc);
}

References igl::embree::EmbreeIntersector::intersectRay(), and igl::unproject_onto_mesh().

Referenced by unproject_onto_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

unproject_onto_mesh() [2/2]

IGL_INLINE bool igl::embree::unproject_onto_mesh	(	const Eigen::Vector2f &	pos,
		const Eigen::MatrixXi &	F,
		const Eigen::Matrix4f &	model,
		const Eigen::Matrix4f &	proj,
		const Eigen::Vector4f &	viewport,
		const EmbreeIntersector &	ei,
		int &	fid,
		int &	vid
	)

{
  Eigen::Vector3f bc;
  if(!igl::embree::unproject_onto_mesh(pos,F,model,proj,viewport,ei,fid,bc))
  {
    return false;
  }
  int i;
  bc.maxCoeff(&i);
  vid = F(fid,i);
  return true;
}

References unproject_onto_mesh().

Here is the call graph for this function:

Variable Documentation

EmbreeIntersector_inited

bool igl::embree::EmbreeIntersector_inited = false

static

Referenced by igl::embree::EmbreeIntersector::deinit(), igl::embree::EmbreeIntersector::global_deinit(), and igl::embree::EmbreeIntersector::global_init().