igl::geodesic::GeodesicAlgorithmBase Class Reference

Inheritance diagram for igl::geodesic::GeodesicAlgorithmBase:

Collaboration diagram for igl::geodesic::GeodesicAlgorithmBase:

Public Types
enum	AlgorithmType { EXACT , DIJKSTRA , SUBDIVISION , UNDEFINED_ALGORITHM }

Public Member Functions
	GeodesicAlgorithmBase (geodesic::Mesh *mesh)
virtual	~GeodesicAlgorithmBase ()
virtual void	propagate (std::vector< SurfacePoint > &sources, double max_propagation_distance=GEODESIC_INF, std::vector< SurfacePoint > *stop_points=NULL)=0
virtual void	trace_back (SurfacePoint &destination, std::vector< SurfacePoint > &path)=0
void	geodesic (SurfacePoint &source, SurfacePoint &destination, std::vector< SurfacePoint > &path)
void	geodesic (std::vector< SurfacePoint > &sources, std::vector< SurfacePoint > &destinations, std::vector< std::vector< SurfacePoint > > &paths)
virtual unsigned	best_source (SurfacePoint &point, double &best_source_distance)=0
virtual void	print_statistics ()
AlgorithmType	type ()
virtual std::string	name ()
geodesic::Mesh *	mesh ()

Protected Types
typedef std::pair< vertex_pointer, double >	stop_vertex_with_distace_type

Protected Member Functions
void	set_stop_conditions (std::vector< SurfacePoint > *stop_points, double stop_distance)
double	stop_distance ()

Protected Attributes
AlgorithmType	m_type
std::vector< stop_vertex_with_distace_type >	m_stop_vertices
double	m_max_propagation_distance
geodesic::Mesh *	m_mesh
double	m_time_consumed
double	m_propagation_distance_stopped

Detailed Description

Member Typedef Documentation

stop_vertex_with_distace_type

typedef std::pair<vertex_pointer, double> igl::geodesic::GeodesicAlgorithmBase::stop_vertex_with_distace_type

protected

Member Enumeration Documentation

AlgorithmType

enum igl::geodesic::GeodesicAlgorithmBase::AlgorithmType

Enumerator
EXACT
DIJKSTRA
SUBDIVISION
UNDEFINED_ALGORITHM

    {
        EXACT,
    DIJKSTRA,
        SUBDIVISION,
    UNDEFINED_ALGORITHM
    };

Constructor & Destructor Documentation

GeodesicAlgorithmBase()

igl::geodesic::GeodesicAlgorithmBase::GeodesicAlgorithmBase ( geodesic::Mesh *  mesh )

inline

                                           :
    m_type(UNDEFINED_ALGORITHM),
    m_max_propagation_distance(1e100),
    m_mesh(mesh)
  {}; 

~GeodesicAlgorithmBase()

virtual igl::geodesic::GeodesicAlgorithmBase::~GeodesicAlgorithmBase ( )

inlinevirtual

{};

Member Function Documentation

best_source()

virtual unsigned igl::geodesic::GeodesicAlgorithmBase::best_source ( SurfacePoint &  point, double &  best_source_distance  )

pure virtual

Implemented in igl::geodesic::GeodesicAlgorithmExact.

geodesic() [1/2]

void igl::geodesic::GeodesicAlgorithmBase::geodesic ( std::vector< SurfacePoint > &  sources, std::vector< SurfacePoint > &  destinations, std::vector< std::vector< SurfacePoint > > &  paths  )

inline

{
  double const max_propagation_distance = GEODESIC_INF;
 
  propagate(sources, 
        max_propagation_distance,
        &destinations);   //we use desinations as stop points
 
  paths.resize(destinations.size());
 
  for(unsigned i=0; i<paths.size(); ++i)
  {
    trace_back(destinations[i], paths[i]);
  }
}

References igl::geodesic::GEODESIC_INF, propagate(), and trace_back().

Here is the call graph for this function:

geodesic() [2/2]

void igl::geodesic::GeodesicAlgorithmBase::geodesic ( SurfacePoint &  source, SurfacePoint &  destination, std::vector< SurfacePoint > &  path  )

inline

{
  std::vector<SurfacePoint> sources(1, source);
  std::vector<SurfacePoint> stop_points(1, destination);
  double const max_propagation_distance = GEODESIC_INF;
 
  propagate(sources, 
        max_propagation_distance,
        &stop_points);
 
  trace_back(destination, path);
}

References igl::geodesic::GEODESIC_INF, propagate(), and trace_back().

Referenced by trace_back().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh()

geodesic::Mesh * igl::geodesic::GeodesicAlgorithmBase::mesh ( )

inline

{return m_mesh;};

References m_mesh.

Referenced by igl::geodesic::GeodesicAlgorithmExact::GeodesicAlgorithmExact().

Here is the caller graph for this function:

name()

std::string igl::geodesic::GeodesicAlgorithmBase::name ( )

inlinevirtual

{
  switch(m_type)
  {
  case EXACT:
    return "exact";
  case DIJKSTRA:
    return "dijkstra";
  case SUBDIVISION:
    return "subdivision";
  default:
  case UNDEFINED_ALGORITHM:
    return "undefined";
  }
}

References DIJKSTRA, EXACT, m_type, SUBDIVISION, and UNDEFINED_ALGORITHM.

print_statistics()

virtual void igl::geodesic::GeodesicAlgorithmBase::print_statistics ( )

inlinevirtual

Reimplemented in igl::geodesic::GeodesicAlgorithmExact.

  {
    std::cout << "propagation step took " << m_time_consumed << " seconds " << std::endl;
  };  

References m_time_consumed.

Referenced by igl::geodesic::GeodesicAlgorithmExact::print_statistics().

Here is the caller graph for this function:

propagate()

virtual void igl::geodesic::GeodesicAlgorithmBase::propagate ( std::vector< SurfacePoint > &  sources, double  max_propagation_distance = GEODESIC_INF, std::vector< SurfacePoint > *  stop_points = NULL  )

pure virtual

Implemented in igl::geodesic::GeodesicAlgorithmExact.

Referenced by geodesic(), and geodesic().

Here is the caller graph for this function:

set_stop_conditions()

void igl::geodesic::GeodesicAlgorithmBase::set_stop_conditions ( std::vector< SurfacePoint > *  stop_points, double  stop_distance  )

inlineprotected

{
  m_max_propagation_distance = stop_distance;
 
  if(!stop_points)
  {
    m_stop_vertices.clear();
    return;
  }
 
  m_stop_vertices.resize(stop_points->size());
 
  std::vector<vertex_pointer> possible_vertices;
  for(unsigned i = 0; i < stop_points->size(); ++i)
  {
    SurfacePoint* point = &(*stop_points)[i];
 
    possible_vertices.clear();
    m_mesh->closest_vertices(point, &possible_vertices);
    
    vertex_pointer closest_vertex = NULL;
    double min_distance = 1e100;
    for(unsigned j = 0; j < possible_vertices.size(); ++j)
    {
      double distance = point->distance(possible_vertices[j]);
      if(distance < min_distance)
      {
        min_distance = distance;
        closest_vertex = possible_vertices[j];
      }
    }
    assert(closest_vertex);
 
    m_stop_vertices[i].first = closest_vertex;
    m_stop_vertices[i].second = min_distance;
  }
}

References igl::geodesic::Mesh::closest_vertices(), igl::geodesic::Point3D::distance(), m_max_propagation_distance, m_mesh, m_stop_vertices, and stop_distance().

Referenced by igl::geodesic::GeodesicAlgorithmExact::propagate().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_distance()

double igl::geodesic::GeodesicAlgorithmBase::stop_distance ( )

inlineprotected

  {
    return m_max_propagation_distance;
  }

References m_max_propagation_distance.

Referenced by igl::geodesic::GeodesicAlgorithmExact::check_stop_conditions(), and set_stop_conditions().

Here is the caller graph for this function:

trace_back()

virtual void igl::geodesic::GeodesicAlgorithmBase::trace_back ( SurfacePoint &  destination, std::vector< SurfacePoint > &  path  )

pure virtual

Implemented in igl::geodesic::GeodesicAlgorithmExact.

References geodesic().

Referenced by geodesic(), and geodesic().

Here is the call graph for this function:

Here is the caller graph for this function:

type()

AlgorithmType igl::geodesic::GeodesicAlgorithmBase::type ( )

inline

{return m_type;};

References m_type.

Member Data Documentation

m_max_propagation_distance

double igl::geodesic::GeodesicAlgorithmBase::m_max_propagation_distance

protected

Referenced by set_stop_conditions(), and stop_distance().

m_mesh

geodesic::Mesh* igl::geodesic::GeodesicAlgorithmBase::m_mesh

protected

Referenced by mesh(), and set_stop_conditions().

m_propagation_distance_stopped

double igl::geodesic::GeodesicAlgorithmBase::m_propagation_distance_stopped

protected

Referenced by igl::geodesic::GeodesicAlgorithmExact::best_first_interval(), igl::geodesic::GeodesicAlgorithmExact::clear(), and igl::geodesic::GeodesicAlgorithmExact::propagate().

m_stop_vertices

std::vector<stop_vertex_with_distace_type> igl::geodesic::GeodesicAlgorithmBase::m_stop_vertices

protected

Referenced by igl::geodesic::GeodesicAlgorithmExact::check_stop_conditions(), and set_stop_conditions().

m_time_consumed

double igl::geodesic::GeodesicAlgorithmBase::m_time_consumed

protected

Referenced by print_statistics(), and igl::geodesic::GeodesicAlgorithmExact::propagate().

m_type

AlgorithmType igl::geodesic::GeodesicAlgorithmBase::m_type

protected

Referenced by igl::geodesic::GeodesicAlgorithmExact::GeodesicAlgorithmExact(), name(), and type().

---

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

• src/libigl/igl/exact_geodesic.cpp