igl::embree::EmbreeIntersector Class Reference

#include <src/libigl/igl/embree/EmbreeIntersector.h>

Collaboration diagram for igl::embree::EmbreeIntersector:

Classes
struct	Triangle
struct	Vertex

Public Types
typedef Eigen::Matrix< float, Eigen::Dynamic, 3 >	PointMatrixType
typedef Eigen::Matrix< int, Eigen::Dynamic, 3 >	FaceMatrixType

Public Member Functions
	EmbreeIntersector ()
virtual	~EmbreeIntersector ()
void	init (const PointMatrixType &V, const FaceMatrixType &F, bool isStatic=false)
void	init (const std::vector< const PointMatrixType * > &V, const std::vector< const FaceMatrixType * > &F, const std::vector< int > &masks, bool isStatic=false)
void	deinit ()
bool	intersectRay (const Eigen::RowVector3f &origin, const Eigen::RowVector3f &direction, Hit &hit, float tnear=0, float tfar=std::numeric_limits< float >::infinity(), int mask=0xFFFFFFFF) const
bool	intersectBeam (const Eigen::RowVector3f &origin, const Eigen::RowVector3f &direction, Hit &hit, float tnear=0, float tfar=std::numeric_limits< float >::infinity(), int mask=0xFFFFFFFF, int geoId=-1, bool closestHit=true, unsigned int samples=4) const
bool	intersectRay (const Eigen::RowVector3f &origin, const Eigen::RowVector3f &direction, std::vector< Hit > &hits, int &num_rays, float tnear=0, float tfar=std::numeric_limits< float >::infinity(), int mask=0xFFFFFFFF) const
bool	intersectSegment (const Eigen::RowVector3f &a, const Eigen::RowVector3f &ab, Hit &hit, int mask=0xFFFFFFFF) const

Static Public Member Functions
static void	global_init ()

Private Member Functions
	EmbreeIntersector (const EmbreeIntersector &that)
EmbreeIntersector &	operator= (const EmbreeIntersector &)
void	createRay (RTCRay &ray, const Eigen::RowVector3f &origin, const Eigen::RowVector3f &direction, float tnear, float tfar, int mask) const

Static Private Member Functions
static void	global_deinit ()

Private Attributes
RTCScene	scene
unsigned	geomID
Vertex *	vertices
Triangle *	triangles
bool	initialized

Detailed Description

---

Class Documentation

igl::embree::EmbreeIntersector::Triangle

struct igl::embree::EmbreeIntersector::Triangle

Class Members
int	v0
int	v1
int	v2

igl::embree::EmbreeIntersector::Vertex

struct igl::embree::EmbreeIntersector::Vertex

Class Members
float	a
float	x
float	y
float	z

Member Typedef Documentation

FaceMatrixType

typedef Eigen::Matrix<int,Eigen::Dynamic,3> igl::embree::EmbreeIntersector::FaceMatrixType

PointMatrixType

typedef Eigen::Matrix<float,Eigen::Dynamic,3> igl::embree::EmbreeIntersector::PointMatrixType

Constructor & Destructor Documentation

EmbreeIntersector() [1/2]

igl::embree::EmbreeIntersector::EmbreeIntersector ( )

inline

  :
  //scene(NULL),
  geomID(0),
  vertices(NULL),
  triangles(NULL),
  initialized(false)
{
}

EmbreeIntersector() [2/2]

igl::embree::EmbreeIntersector::EmbreeIntersector ( const EmbreeIntersector &  that )

inlineprivate

  :// To make -Weffc++ happy
  //scene(NULL),
  geomID(0),
  vertices(NULL),
  triangles(NULL),
  initialized(false)
{
  assert(false && "Embree: Copying EmbreeIntersector is not allowed");
}

~EmbreeIntersector()

igl::embree::EmbreeIntersector::~EmbreeIntersector ( )

inlinevirtual

{
  if(initialized)
    deinit();
}

References initialized.

Member Function Documentation

createRay()

void igl::embree::EmbreeIntersector::createRay ( RTCRay &  ray, const Eigen::RowVector3f &  origin, const Eigen::RowVector3f &  direction, float  tnear, float  tfar, int  mask  ) const

inlineprivate

{
  ray.org[0] = origin[0];
  ray.org[1] = origin[1];
  ray.org[2] = origin[2];
  ray.dir[0] = direction[0];
  ray.dir[1] = direction[1];
  ray.dir[2] = direction[2];
  ray.tnear = tnear;
  ray.tfar = tfar;
  ray.geomID = RTC_INVALID_GEOMETRY_ID;
  ray.primID = RTC_INVALID_GEOMETRY_ID;
  ray.instID = RTC_INVALID_GEOMETRY_ID;
  ray.mask = mask;
  ray.time = 0.0f;
}

References RTC_INVALID_GEOMETRY_ID.

deinit()

void igl::embree::EmbreeIntersector::deinit ( )

inline

{
  if(EmbreeIntersector_inited && scene)
  {
    rtcDeleteScene(scene);
 
    if(rtcGetError() != RTC_NO_ERROR)
    {
        std::cerr << "Embree: An error occurred while resetting!" << std::endl;
    }
#ifdef IGL_VERBOSE
    else
    {
      std::cerr << "Embree: geometry removed." << std::endl;
    }
#endif
  }
}

References igl::embree::EmbreeIntersector_inited, RTC_NO_ERROR, rtcDeleteScene(), and rtcGetError().

Here is the call graph for this function:

global_deinit()

void igl::embree::EmbreeIntersector::global_deinit ( )

inlinestaticprivate

{
  EmbreeIntersector_inited = false;
  rtcExit();
}

References igl::embree::EmbreeIntersector_inited, and rtcExit().

Here is the call graph for this function:

global_init()

void igl::embree::EmbreeIntersector::global_init ( )

inlinestatic

{
  if(!EmbreeIntersector_inited)
  {
    rtcInit();
    if(rtcGetError() != RTC_NO_ERROR)
      std::cerr << "Embree: An error occurred while initializing embree core!" << std::endl;
#ifdef IGL_VERBOSE
    else
      std::cerr << "Embree: core initialized." << std::endl;
#endif
    EmbreeIntersector_inited = true;
  }
}

References igl::embree::EmbreeIntersector_inited, RTC_NO_ERROR, rtcGetError(), and rtcInit().

Here is the call graph for this function:

init() [1/2]

void igl::embree::EmbreeIntersector::init ( const PointMatrixType &  V, const FaceMatrixType &  F, bool  isStatic = false  )

inline

{
  std::vector<const PointMatrixType*> Vtemp;
  std::vector<const FaceMatrixType*> Ftemp;
  std::vector<int> masks;
  Vtemp.push_back(&V);
  Ftemp.push_back(&F);
  masks.push_back(0xFFFFFFFF);
  init(Vtemp,Ftemp,masks,isStatic);
}

Referenced by igl::embree::ambient_occlusion(), igl::embree::bone_heat(), igl::embree::bone_visible(), igl::embree::line_mesh_intersection(), igl::embree::reorient_facets_raycast(), and igl::embree::shape_diameter_function().

Here is the caller graph for this function:

init() [2/2]

void igl::embree::EmbreeIntersector::init ( const std::vector< const PointMatrixType * > &  V, const std::vector< const FaceMatrixType * > &  F, const std::vector< int > &  masks, bool  isStatic = false  )

inline

{
 
  if(initialized)
    deinit();
 
  using namespace std;
  global_init();
 
  if(V.size() == 0 || F.size() == 0)
  {
    std::cerr << "Embree: No geometry specified!";
    return;
  }
 
  // create a scene
  RTCSceneFlags flags = RTC_SCENE_ROBUST | RTC_SCENE_HIGH_QUALITY;
  if(isStatic)
    flags = flags | RTC_SCENE_STATIC;
  scene = rtcNewScene(flags,RTC_INTERSECT1);
 
  for(int g=0;g<(int)V.size();g++)
  {
    // create triangle mesh geometry in that scene
    geomID = rtcNewTriangleMesh(scene,RTC_GEOMETRY_STATIC,F[g]->rows(),V[g]->rows(),1);
 
    // fill vertex buffer
    vertices = (Vertex*)rtcMapBuffer(scene,geomID,RTC_VERTEX_BUFFER);
    for(int i=0;i<(int)V[g]->rows();i++)
    {
      vertices[i].x = (float)V[g]->coeff(i,0);
      vertices[i].y = (float)V[g]->coeff(i,1);
      vertices[i].z = (float)V[g]->coeff(i,2);
    }
    rtcUnmapBuffer(scene,geomID,RTC_VERTEX_BUFFER);
 
    // fill triangle buffer
    triangles = (Triangle*) rtcMapBuffer(scene,geomID,RTC_INDEX_BUFFER);
    for(int i=0;i<(int)F[g]->rows();i++)
    {
      triangles[i].v0 = (int)F[g]->coeff(i,0);
      triangles[i].v1 = (int)F[g]->coeff(i,1);
      triangles[i].v2 = (int)F[g]->coeff(i,2);
    }
    rtcUnmapBuffer(scene,geomID,RTC_INDEX_BUFFER);
 
    rtcSetMask(scene,geomID,masks[g]);
  }
 
  rtcCommit(scene);
 
  if(rtcGetError() != RTC_NO_ERROR)
      std::cerr << "Embree: An error occurred while initializing the provided geometry!" << endl;
#ifdef IGL_VERBOSE
  else
    std::cerr << "Embree: geometry added." << endl;
#endif
 
  initialized = true;
}

References initialized, RTC_GEOMETRY_STATIC, RTC_INDEX_BUFFER, RTC_INTERSECT1, RTC_NO_ERROR, RTC_SCENE_HIGH_QUALITY, RTC_SCENE_ROBUST, RTC_SCENE_STATIC, RTC_VERTEX_BUFFER, rtcCommit(), rtcGetError(), rtcMapBuffer(), rtcNewScene(), rtcNewTriangleMesh(), rtcSetMask(), and rtcUnmapBuffer().

Here is the call graph for this function:

intersectBeam()

bool igl::embree::EmbreeIntersector::intersectBeam ( const Eigen::RowVector3f &  origin, const Eigen::RowVector3f &  direction, Hit &  hit, float  tnear = 0, float  tfar = std::numeric_limits<float>::infinity(), int  mask = 0xFFFFFFFF, int  geoId = -1, bool  closestHit = true, unsigned int  samples = 4  ) const

inline

{
  bool hasHit = false;
  Hit bestHit;
 
  if(closestHit)
    bestHit.t = std::numeric_limits<float>::max();
  else
    bestHit.t = 0;
 
  if((intersectRay(origin,direction,hit,tnear,tfar,mask) && (hit.gid == geoId || geoId == -1)))
  {
    bestHit = hit;
    hasHit = true;
  }
 
  // sample points around actual ray (conservative hitcheck)
  const float eps= 1e-5;
 
  Eigen::RowVector3f up(0,1,0);
  Eigen::RowVector3f offset = direction.cross(up).normalized();
 
  Eigen::Matrix3f rot = Eigen::AngleAxis<float>(2*3.14159265358979/samples,direction).toRotationMatrix();
 
  for(int r=0;r<(int)samples;r++)
  {
    if(intersectRay(origin+offset*eps,direction,hit,tnear,tfar,mask) && 
        ((closestHit && (hit.t < bestHit.t)) || 
           (!closestHit && (hit.t > bestHit.t)))  &&
        (hit.gid == geoId || geoId == -1))
    {
      bestHit = hit;
      hasHit = true;
    }
    offset = rot*offset.transpose();
  }
 
  hit = bestHit;
  return hasHit;
}

References igl::Hit::gid, igl::Hit::t, and Eigen::AngleAxis< _Scalar >::toRotationMatrix().

Referenced by igl::embree::line_mesh_intersection().

Here is the call graph for this function:

Here is the caller graph for this function:

intersectRay() [1/2]

bool igl::embree::EmbreeIntersector::intersectRay ( const Eigen::RowVector3f &  origin, const Eigen::RowVector3f &  direction, Hit &  hit, float  tnear = 0, float  tfar = std::numeric_limits<float>::infinity(), int  mask = 0xFFFFFFFF  ) const

inline

{
  RTCRay ray;
  createRay(ray, origin,direction,tnear,tfar,mask);
 
  // shot ray
  rtcIntersect(scene,ray);
#ifdef IGL_VERBOSE
  if(rtcGetError() != RTC_NO_ERROR)
      std::cerr << "Embree: An error occurred while resetting!" << std::endl;
#endif
 
  if((unsigned)ray.geomID != RTC_INVALID_GEOMETRY_ID)
  {
    hit.id = ray.primID;
    hit.gid = ray.geomID;
    hit.u = ray.u;
    hit.v = ray.v;
    hit.t = ray.tfar;
    return true;
  }
 
  return false;
}

References igl::Hit::gid, igl::Hit::id, RTC_INVALID_GEOMETRY_ID, RTC_NO_ERROR, rtcGetError(), rtcIntersect(), igl::Hit::t, igl::Hit::u, and igl::Hit::v.

Referenced by igl::embree::ambient_occlusion(), igl::embree::reorient_facets_raycast(), igl::embree::shape_diameter_function(), igl::embree::unproject_in_mesh(), and igl::embree::unproject_onto_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

intersectRay() [2/2]

bool igl::embree::EmbreeIntersector::intersectRay ( const Eigen::RowVector3f &  origin, const Eigen::RowVector3f &  direction, std::vector< Hit > &  hits, int &  num_rays, float  tnear = 0, float  tfar = std::numeric_limits<float>::infinity(), int  mask = 0xFFFFFFFF  ) const

inline

{
  using namespace std;
  num_rays = 0;
  hits.clear();
  int last_id0 = -1;
  double self_hits = 0;
  // This epsilon is directly correleated to the number of missed hits, smaller
  // means more accurate and slower
  //const double eps = DOUBLE_EPS;
  const double eps = FLOAT_EPS;
  double min_t = tnear;
  bool large_hits_warned = false;
  RTCRay ray;
  createRay(ray,origin,direction,tnear,tfar,mask);
 
  while(true)
  {
    ray.tnear = min_t;
    ray.tfar = tfar;
    ray.geomID = RTC_INVALID_GEOMETRY_ID;
    ray.primID = RTC_INVALID_GEOMETRY_ID;
    ray.instID = RTC_INVALID_GEOMETRY_ID;
    num_rays++;
    rtcIntersect(scene,ray);
    if((unsigned)ray.geomID != RTC_INVALID_GEOMETRY_ID)
    {
      // Hit self again, progressively advance
      if(ray.primID == last_id0 || ray.tfar <= min_t)
      {
        // push min_t a bit more
        //double t_push = pow(2.0,self_hits-4)*(hit.t<eps?eps:hit.t);
        double t_push = pow(2.0,self_hits)*eps;
        #ifdef IGL_VERBOSE
        std::cerr<<"  t_push: "<<t_push<<endl;
        #endif
        //o = o+t_push*d;
        min_t += t_push;
        self_hits++;
      }
      else
      {
        Hit hit;
        hit.id = ray.primID;
        hit.gid = ray.geomID;
        hit.u = ray.u;
        hit.v = ray.v;
        hit.t = ray.tfar;
        hits.push_back(hit);
#ifdef IGL_VERBOSE
        std::cerr<<"  t: "<<hit.t<<endl;
#endif
        // Instead of moving origin, just change min_t. That way calculations
        // all use exactly same origin values
        min_t = ray.tfar;
 
        // reset t_scale
        self_hits = 0;
      }
      last_id0 = ray.primID;
    }
    else
      break; // no more hits
 
    if(hits.size()>1000 && !large_hits_warned)
    {
      std::cout<<"Warning: Large number of hits..."<<endl;
      std::cout<<"[ ";
      for(vector<Hit>::iterator hit = hits.begin(); hit != hits.end();hit++)
      {
        std::cout<<(hit->id+1)<<" ";
      }
 
      std::cout.precision(std::numeric_limits< double >::digits10);
      std::cout<<"[ ";
 
      for(vector<Hit>::iterator hit = hits.begin(); hit != hits.end(); hit++)
      {
        std::cout<<(hit->t)<<endl;;
      }
 
      std::cout<<"]"<<endl;
      large_hits_warned = true;
 
      return hits.empty();
    }
  }
 
  return hits.empty();
}

References igl::FLOAT_EPS, igl::Hit::gid, igl::Hit::id, RTC_INVALID_GEOMETRY_ID, rtcIntersect(), igl::Hit::t, igl::Hit::u, and igl::Hit::v.

Here is the call graph for this function:

intersectSegment()

bool igl::embree::EmbreeIntersector::intersectSegment ( const Eigen::RowVector3f &  a, const Eigen::RowVector3f &  ab, Hit &  hit, int  mask = 0xFFFFFFFF  ) const

inline

{
  RTCRay ray;
  createRay(ray,a,ab,0,1.0,mask);
 
  rtcIntersect(scene,ray);
 
  if((unsigned)ray.geomID != RTC_INVALID_GEOMETRY_ID)
  {
    hit.id = ray.primID;
    hit.gid = ray.geomID;
    hit.u = ray.u;
    hit.v = ray.v;
    hit.t = ray.tfar;
    return true;
  }
 
  return false;
}

References igl::Hit::gid, igl::Hit::id, RTC_INVALID_GEOMETRY_ID, rtcIntersect(), igl::Hit::t, igl::Hit::u, and igl::Hit::v.

Referenced by igl::embree::bone_visible().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

igl::embree::EmbreeIntersector & igl::embree::EmbreeIntersector::operator= ( const EmbreeIntersector &  )

inlineprivate

{
  assert(false && "Embree: Assigning an EmbreeIntersector is not allowed");
  return *this;
}

Member Data Documentation

geomID

unsigned igl::embree::EmbreeIntersector::geomID

private

initialized

bool igl::embree::EmbreeIntersector::initialized

private

scene

RTCScene igl::embree::EmbreeIntersector::scene

private

triangles

Triangle* igl::embree::EmbreeIntersector::triangles

private

vertices

Vertex* igl::embree::EmbreeIntersector::vertices

private

---

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

• src/libigl/igl/embree/EmbreeIntersector.h