igl::geodesic Namespace Reference

Classes
class	Edge
struct	edge_visible_from_source
class	Face
class	GeodesicAlgorithmBase
class	GeodesicAlgorithmExact
struct	HalfEdge
class	Interval
class	IntervalList
struct	IntervalWithStop
class	MemoryAllocator
class	Mesh
class	MeshElementBase
class	OutputBuffer
class	Point3D
class	SimlpeMemoryAllocator
class	SimpleVector
class	SortedSources
class	SurfacePoint
class	SurfacePointWithIndex
class	Vertex

Typedefs
typedef Vertex *	vertex_pointer
typedef Edge *	edge_pointer
typedef Face *	face_pointer
typedef Mesh *	mesh_pointer
typedef MeshElementBase *	base_pointer
typedef Interval *	interval_pointer
typedef IntervalList *	list_pointer

Enumerations
enum	PointType { VERTEX , EDGE , FACE , UNDEFINED_POINT }

Functions
double	cos_from_edges (double const a, double const b, double const c)
double	angle_from_edges (double const a, double const b, double const c)
template<class Points , class Faces >
bool	read_mesh_from_file (char *filename, Points &points, Faces &faces)
bool	operator< (const HalfEdge &x, const HalfEdge &y)
bool	operator!= (const HalfEdge &x, const HalfEdge &y)
bool	operator== (const HalfEdge &x, const HalfEdge &y)
void	fill_surface_point_structure (geodesic::SurfacePoint *point, double *data, Mesh *mesh)
void	fill_surface_point_double (geodesic::SurfacePoint *point, double *data, long mesh_id)
double	length (std::vector< SurfacePoint > &path)
void	print_info_about_path (std::vector< SurfacePoint > &path)

Variables
double const	GEODESIC_INF = 1e100
double const	SMALLEST_INTERVAL_RATIO = 1e-6

---

Class Documentation

igl::geodesic::edge_visible_from_source

struct igl::geodesic::edge_visible_from_source

Collaboration diagram for igl::geodesic::edge_visible_from_source:

Class Members
edge_pointer	edge
unsigned	source

igl::geodesic::HalfEdge

struct igl::geodesic::HalfEdge

Class Members
unsigned	face_id
unsigned	vertex_0
unsigned	vertex_1

Typedef Documentation

base_pointer

typedef MeshElementBase* igl::geodesic::base_pointer

edge_pointer

typedef Edge* igl::geodesic::edge_pointer

face_pointer

typedef Face* igl::geodesic::face_pointer

interval_pointer

typedef Interval* igl::geodesic::interval_pointer

list_pointer

typedef IntervalList* igl::geodesic::list_pointer

mesh_pointer

typedef Mesh* igl::geodesic::mesh_pointer

vertex_pointer

typedef Vertex* igl::geodesic::vertex_pointer

Enumeration Type Documentation

PointType

enum igl::geodesic::PointType

Enumerator
VERTEX
EDGE
FACE
UNDEFINED_POINT

{
    VERTEX,
    EDGE,
    FACE,
  UNDEFINED_POINT
};

Function Documentation

angle_from_edges()

double igl::geodesic::angle_from_edges ( double const  a, double const  b, double const  c  )

inline

{
  return acos(cos_from_edges(a,b,c));
}

References acos(), and cos_from_edges().

Referenced by igl::geodesic::Mesh::build_adjacencies().

Here is the call graph for this function:

Here is the caller graph for this function:

cos_from_edges()

double igl::geodesic::cos_from_edges ( double const  a, double const  b, double const  c  )

inline

{
  assert(a>1e-50);
  assert(b>1e-50);
  assert(c>1e-50);
 
  double result = (b*b + c*c - a*a)/(2.0*b*c);
  result = std::max(result, -1.0);
  return std::min(result, 1.0);
}

Referenced by angle_from_edges().

Here is the caller graph for this function:

fill_surface_point_double()

void igl::geodesic::fill_surface_point_double ( geodesic::SurfacePoint *  point, double *  data, long  mesh_id  )

inline

{
  data[0] = point->x();
  data[1] = point->y();
  data[2] = point->z();
  data[4] = point->base_element()->id();
 
  if(point->type() == VERTEX)   //vertex
  {
    data[3] = 0;
  }
  else if(point->type() == EDGE)  //edge
  {
    data[3] = 1;
  }
  else        //face
  {
    data[3] = 2;
  }
}

References igl::geodesic::SurfacePoint::base_element(), EDGE, igl::geodesic::MeshElementBase::id(), igl::geodesic::SurfacePoint::type(), VERTEX, igl::geodesic::Point3D::x(), igl::geodesic::Point3D::y(), and igl::geodesic::Point3D::z().

Here is the call graph for this function:

fill_surface_point_structure()

void igl::geodesic::fill_surface_point_structure ( geodesic::SurfacePoint *  point, double *  data, Mesh *  mesh  )

inline

{
  point->set(data);
  unsigned type = (unsigned) data[3];
  unsigned id = (unsigned) data[4];
  
 
  if(type == 0)   //vertex
  {
    point->base_element() = &mesh->vertices()[id];
  }
  else if(type == 1)  //edge
  {
    point->base_element() = &mesh->edges()[id];
  }
  else        //face
  {
    point->base_element() = &mesh->faces()[id];
  }
}

References igl::geodesic::SurfacePoint::base_element(), igl::geodesic::Mesh::edges(), igl::geodesic::Mesh::faces(), igl::geodesic::Point3D::set(), and igl::geodesic::Mesh::vertices().

Here is the call graph for this function:

length()

double igl::geodesic::length ( std::vector< SurfacePoint > &  path )

inline

{
  double length = 0;
  if(!path.empty())
  {
    for(unsigned i=0; i<path.size()-1; ++i)
    {
      length += path[i].distance(&path[i+1]);
    }
  }
  return length;
}

References length().

Referenced by igl::geodesic::GeodesicAlgorithmExact::construct_propagated_intervals(), igl::geodesic::IntervalList::covering_interval(), igl::exact_geodesic(), length(), print_info_about_path(), igl::geodesic::GeodesicAlgorithmExact::propagate(), and igl::geodesic::Interval::signal().

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

bool igl::geodesic::operator!= ( const HalfEdge &  x, const HalfEdge &  y  )

inline

{
  return x.vertex_0 != y.vertex_0 || x.vertex_1 != y.vertex_1;
}

operator<()

bool igl::geodesic::operator< ( const HalfEdge &  x, const HalfEdge &  y  )

inline

{
  if(x.vertex_0 == y.vertex_0)
  {
      return x.vertex_1 < y.vertex_1;
  }
  else
  {
    return x.vertex_0 < y.vertex_0;
  }
}

operator==()

bool igl::geodesic::operator== ( const HalfEdge &  x, const HalfEdge &  y  )

inline

{
  return x.vertex_0 == y.vertex_0 && x.vertex_1 == y.vertex_1;
}

print_info_about_path()

void igl::geodesic::print_info_about_path ( std::vector< SurfacePoint > &  path )

inline

{
  std::cout << "number of the points in the path = " << path.size()
        << ", length of the path = " << length(path) 
        << std::endl;
}

References length().

Here is the call graph for this function:

read_mesh_from_file()

template<class Points , class Faces >

bool igl::geodesic::read_mesh_from_file ( char *  filename, Points &  points, Faces &  faces  )

inline

{
  std::ifstream file(filename);
  assert(file.is_open());
  if(!file.is_open()) return false;
  
  unsigned num_points;
  file >> num_points;
  assert(num_points>=3);
 
  unsigned num_faces;
  file >> num_faces;
 
  points.resize(num_points*3);
  for(typename Points::iterator i=points.begin(); i!=points.end(); ++i)
  {
    file >> *i;
  }
 
  faces.resize(num_faces*3);
  for(typename Faces::iterator i=faces.begin(); i!=faces.end(); ++i)
  {
    file >> *i;
  }
  file.close();
 
  return true;
}

Variable Documentation

GEODESIC_INF

double const igl::geodesic::GEODESIC_INF = 1e100

Referenced by igl::geodesic::GeodesicAlgorithmExact::best_first_interval(), igl::geodesic::GeodesicAlgorithmExact::clear(), igl::geodesic::Interval::compute_min_distance(), igl::geodesic::GeodesicAlgorithmExact::compute_propagated_parameters(), igl::geodesic::GeodesicAlgorithmExact::erase_from_queue(), igl::geodesic::Interval::find_closest_point(), igl::geodesic::IntervalList::find_closest_point(), igl::geodesic::GeodesicAlgorithmBase::geodesic(), igl::geodesic::GeodesicAlgorithmBase::geodesic(), igl::geodesic::Interval::initialize(), igl::geodesic::GeodesicAlgorithmExact::intersect_intervals(), igl::geodesic::Interval::max_distance(), igl::geodesic::GeodesicAlgorithmExact::propagate(), igl::geodesic::Interval::signal(), igl::geodesic::IntervalList::signal(), and igl::geodesic::GeodesicAlgorithmExact::trace_back().

SMALLEST_INTERVAL_RATIO

double const igl::geodesic::SMALLEST_INTERVAL_RATIO = 1e-6

Referenced by igl::geodesic::GeodesicAlgorithmExact::construct_propagated_intervals(), igl::geodesic::Interval::find_closest_point(), igl::geodesic::GeodesicAlgorithmExact::intersect_intervals(), igl::geodesic::GeodesicAlgorithmExact::trace_back(), and igl::geodesic::GeodesicAlgorithmExact::update_list_and_queue().