igl::geodesic::Interval Class Reference

Inheritance diagram for igl::geodesic::Interval:

Collaboration diagram for igl::geodesic::Interval:

Public Types
enum	DirectionType { FROM_FACE_0 , FROM_FACE_1 , FROM_SOURCE , UNDEFINED_DIRECTION }

Public Member Functions
	Interval ()
	~Interval ()
double	signal (double x)
double	max_distance (double end)
void	compute_min_distance (double stop)
bool	operator() (interval_pointer const x, interval_pointer const y) const
double	stop ()
double	hypotenuse (double a, double b)
void	find_closest_point (double const x, double const y, double &offset, double &distance)
double &	start ()
double &	d ()
double &	pseudo_x ()
double &	pseudo_y ()
double &	min ()
interval_pointer &	next ()
edge_pointer &	edge ()
DirectionType &	direction ()
bool	visible_from_source ()
unsigned &	source_index ()
void	initialize (edge_pointer edge, SurfacePoint *point=NULL, unsigned source_index=0)

Protected Attributes
double	m_start
double	m_d
double	m_pseudo_x
double	m_pseudo_y
double	m_min
interval_pointer	m_next
edge_pointer	m_edge
unsigned	m_source_index
DirectionType	m_direction

Detailed Description

Member Enumeration Documentation

DirectionType

enum igl::geodesic::Interval::DirectionType

Enumerator
FROM_FACE_0
FROM_FACE_1
FROM_SOURCE
UNDEFINED_DIRECTION

    {
        FROM_FACE_0,
    FROM_FACE_1,
    FROM_SOURCE,
    UNDEFINED_DIRECTION
    };

Constructor & Destructor Documentation

Interval()

igl::geodesic::Interval::Interval ( )

inline

{};

~Interval()

igl::geodesic::Interval::~Interval ( )

inline

{};

Member Function Documentation

compute_min_distance()

void igl::geodesic::Interval::compute_min_distance ( double  stop )

inline

  {
    assert(stop > m_start);
 
    if(m_d == GEODESIC_INF)
    {
      m_min = GEODESIC_INF;
    }
    else if(m_start > m_pseudo_x)
    {
      m_min = signal(m_start);
    }
    else if(stop < m_pseudo_x)
    {
      m_min = signal(stop);
    }
    else
    {
      assert(m_pseudo_y<=0);
      m_min = m_d - m_pseudo_y;
    } 
  }

References igl::geodesic::GEODESIC_INF, m_d, m_min, m_pseudo_x, m_pseudo_y, m_start, signal(), and stop().

Referenced by initialize(), igl::geodesic::GeodesicAlgorithmExact::initialize_propagation_data(), and igl::geodesic::GeodesicAlgorithmExact::update_list_and_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

d()

double & igl::geodesic::Interval::d ( )

inline

{return m_d;};

References m_d.

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

Here is the caller graph for this function:

direction()

DirectionType & igl::geodesic::Interval::direction ( )

inline

{return m_direction;};

References m_direction.

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

Here is the caller graph for this function:

edge()

edge_pointer & igl::geodesic::Interval::edge ( )

inline

{return m_edge;};

References m_edge.

Referenced by igl::geodesic::GeodesicAlgorithmExact::construct_propagated_intervals(), initialize(), igl::geodesic::GeodesicAlgorithmExact::intersect_intervals(), igl::geodesic::GeodesicAlgorithmExact::propagate(), and igl::geodesic::GeodesicAlgorithmExact::trace_back().

Here is the caller graph for this function:

find_closest_point()

void igl::geodesic::Interval::find_closest_point ( double const  x, double const  y, double &  offset, double &  distance  )

inline

  {
    if(m_d == GEODESIC_INF)
    {
      r = GEODESIC_INF;
      d_out = GEODESIC_INF;
      return;
    }
 
    double hc = -m_pseudo_y;
    double rc = m_pseudo_x;
    double end = stop();
 
    double local_epsilon = SMALLEST_INTERVAL_RATIO*m_edge->length();
    if(std::abs(hs+hc) < local_epsilon)
    {
      if(rs<=m_start)
      {
        r = m_start;
        d_out = signal(m_start) + std::abs(rs - m_start);
      }
      else if(rs>=end)
      {
        r = end;
        d_out = signal(end) + fabs(end - rs);
      }
      else
      {
        r = rs;
        d_out = signal(rs);
      }
    }
    else
    {
      double ri = (rs*hc + hs*rc)/(hs+hc);
 
      if(ri<m_start)
      {
        r = m_start;
        d_out = signal(m_start) + hypotenuse(m_start - rs, hs);
      }
      else if(ri>end)
      {
        r = end;
        d_out = signal(end) + hypotenuse(end - rs, hs);
      }
      else
      {
        r = ri;
        d_out = m_d + hypotenuse(rc - rs, hc + hs);
      }
    }
  }

References igl::geodesic::GEODESIC_INF, hypotenuse(), igl::geodesic::Edge::length(), m_d, m_edge, m_pseudo_x, m_pseudo_y, m_start, signal(), igl::geodesic::SMALLEST_INTERVAL_RATIO, and stop().

Referenced by igl::geodesic::IntervalList::find_closest_point().

Here is the call graph for this function:

Here is the caller graph for this function:

hypotenuse()

double igl::geodesic::Interval::hypotenuse ( double  a, double  b  )

inline

  {
    return sqrt(a*a + b*b);
  }

References sqrt().

Referenced by find_closest_point().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize()

void igl::geodesic::Interval::initialize ( edge_pointer  edge, SurfacePoint *  point = NULL, unsigned  source_index = 0  )

inline

{
  m_next = NULL;
  //m_geodesic_previous = NULL; 
  m_direction = UNDEFINED_DIRECTION;
  m_edge = edge;
  m_source_index = source_index;
 
  m_start = 0.0;
  //m_stop = edge->length();
  if(!source)
  {
    m_d = GEODESIC_INF;
    m_min = GEODESIC_INF;
    return;
  }
  m_d = 0;
 
  if(source->base_element()->type() == VERTEX)
  {
    if(source->base_element()->id() == edge->v0()->id())
    {
      m_pseudo_x = 0.0;
      m_pseudo_y = 0.0;
      m_min = 0.0;
      return;
    }
    else if(source->base_element()->id() == edge->v1()->id())
    {
      m_pseudo_x = stop();
      m_pseudo_y = 0.0;
      m_min = 0.0;
      return;
    }
  }
 
  edge->local_coordinates(source, m_pseudo_x, m_pseudo_y);
  m_pseudo_y = -m_pseudo_y;
 
  compute_min_distance(stop());
} 

References igl::geodesic::SurfacePoint::base_element(), compute_min_distance(), edge(), igl::geodesic::GEODESIC_INF, igl::geodesic::MeshElementBase::id(), igl::geodesic::Edge::local_coordinates(), m_d, m_direction, m_edge, m_min, m_next, m_pseudo_x, m_pseudo_y, m_source_index, m_start, source_index(), stop(), igl::geodesic::MeshElementBase::type(), UNDEFINED_DIRECTION, igl::geodesic::Edge::v0(), igl::geodesic::Edge::v1(), and igl::geodesic::VERTEX.

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

Here is the call graph for this function:

Here is the caller graph for this function:

max_distance()

double igl::geodesic::Interval::max_distance ( double  end )

inline

  {
    if(m_d == GEODESIC_INF)
    {
      return GEODESIC_INF;
    }
    else
    {
      double a = std::abs(m_start - m_pseudo_x);
      double b = std::abs(end - m_pseudo_x);
 
      return a > b ? m_d + sqrt(a*a + m_pseudo_y*m_pseudo_y): 
               m_d + sqrt(b*b + m_pseudo_y*m_pseudo_y);
    }
  }

References igl::geodesic::GEODESIC_INF, m_d, m_pseudo_x, m_pseudo_y, m_start, and sqrt().

Here is the call graph for this function:

min()

double & igl::geodesic::Interval::min ( )

inline

{return m_min;};

References m_min.

Referenced by igl::geodesic::GeodesicAlgorithmExact::construct_propagated_intervals(), igl::geodesic::GeodesicAlgorithmExact::erase_from_queue(), igl::geodesic::IntervalList::find_closest_point(), and igl::geodesic::GeodesicAlgorithmExact::intersect_intervals().

Here is the caller graph for this function:

next()

interval_pointer & igl::geodesic::Interval::next ( )

inline

{return m_next;};

References m_next.

Referenced by igl::geodesic::GeodesicAlgorithmExact::construct_propagated_intervals(), igl::geodesic::IntervalList::covering_interval(), igl::geodesic::IntervalList::find_closest_point(), igl::geodesic::IntervalList::last(), igl::geodesic::IntervalList::number_of_intervals(), igl::geodesic::GeodesicAlgorithmExact::propagate(), and igl::geodesic::GeodesicAlgorithmExact::update_list_and_queue().

Here is the caller graph for this function:

operator()()

bool igl::geodesic::Interval::operator() ( interval_pointer const  x, interval_pointer const  y  ) const

inline

  {
    if(x->min() != y->min())
    {
      return x->min() < y->min();
    }
    else if(x->start() != y->start())
    {
      return x->start() < y->start();
    }
    else
    {
      return x->edge()->id() < y->edge()->id();
    }
  }

pseudo_x()

double & igl::geodesic::Interval::pseudo_x ( )

inline

{return m_pseudo_x;};

References m_pseudo_x.

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

Here is the caller graph for this function:

pseudo_y()

double & igl::geodesic::Interval::pseudo_y ( )

inline

{return m_pseudo_y;};

References m_pseudo_y.

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

Here is the caller graph for this function:

signal()

double igl::geodesic::Interval::signal ( double  x )

inline

  {
    assert(x>=0.0 && x <= m_edge->length());
 
    if(m_d == GEODESIC_INF)
    {
      return GEODESIC_INF;
    }
    else
    {
      double dx = x - m_pseudo_x;
      if(m_pseudo_y == 0.0)
      {
        return m_d + std::abs(dx);
      }
      else
      {
        return m_d + sqrt(dx*dx + m_pseudo_y*m_pseudo_y);
      }
    }
  }

References igl::geodesic::GEODESIC_INF, igl::geodesic::length(), m_d, m_pseudo_x, m_pseudo_y, and sqrt().

Referenced by igl::geodesic::GeodesicAlgorithmExact::best_first_interval(), compute_min_distance(), find_closest_point(), igl::geodesic::GeodesicAlgorithmExact::intersect_intervals(), and igl::geodesic::IntervalList::signal().

Here is the call graph for this function:

Here is the caller graph for this function:

source_index()

unsigned & igl::geodesic::Interval::source_index ( )

inline

{return m_source_index;};

References m_source_index.

Referenced by igl::geodesic::GeodesicAlgorithmExact::best_first_interval(), igl::geodesic::GeodesicAlgorithmExact::construct_propagated_intervals(), initialize(), igl::geodesic::GeodesicAlgorithmExact::trace_back(), and igl::geodesic::GeodesicAlgorithmExact::visible_from_source().

Here is the caller graph for this function:

start()

double & igl::geodesic::Interval::start ( )

inline

{return m_start;}; 

References m_start.

Referenced by igl::geodesic::GeodesicAlgorithmExact::compute_propagated_parameters(), igl::geodesic::GeodesicAlgorithmExact::construct_propagated_intervals(), igl::geodesic::GeodesicAlgorithmExact::intersect_intervals(), igl::geodesic::GeodesicAlgorithmExact::propagate(), stop(), and igl::geodesic::GeodesicAlgorithmExact::update_list_and_queue().

Here is the caller graph for this function:

stop()

double igl::geodesic::Interval::stop ( )

inline

  {
    return m_next ? m_next->start() : m_edge->length();
  }   

References igl::geodesic::Edge::length(), m_edge, m_next, and start().

Referenced by compute_min_distance(), igl::geodesic::IntervalList::covering_interval(), find_closest_point(), initialize(), igl::geodesic::GeodesicAlgorithmExact::intersect_intervals(), igl::geodesic::GeodesicAlgorithmExact::propagate(), and igl::geodesic::GeodesicAlgorithmExact::update_list_and_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

visible_from_source()

bool igl::geodesic::Interval::visible_from_source ( )

inline

{return m_direction == FROM_SOURCE;};

References FROM_SOURCE, and m_direction.

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

Here is the caller graph for this function:

Member Data Documentation

m_d

double igl::geodesic::Interval::m_d

protected

Referenced by compute_min_distance(), d(), find_closest_point(), initialize(), max_distance(), and signal().

m_direction

DirectionType igl::geodesic::Interval::m_direction

protected

Referenced by direction(), initialize(), and visible_from_source().

m_edge

edge_pointer igl::geodesic::Interval::m_edge

protected

Referenced by edge(), find_closest_point(), initialize(), and stop().

m_min

double igl::geodesic::Interval::m_min

protected

Referenced by compute_min_distance(), initialize(), and min().

m_next

interval_pointer igl::geodesic::Interval::m_next

protected

Referenced by initialize(), next(), and stop().

m_pseudo_x

double igl::geodesic::Interval::m_pseudo_x

protected

Referenced by compute_min_distance(), find_closest_point(), initialize(), max_distance(), pseudo_x(), and signal().

m_pseudo_y

double igl::geodesic::Interval::m_pseudo_y

protected

Referenced by compute_min_distance(), find_closest_point(), initialize(), max_distance(), pseudo_y(), and signal().

m_source_index

unsigned igl::geodesic::Interval::m_source_index

protected

Referenced by initialize(), and source_index().

m_start

double igl::geodesic::Interval::m_start

protected

Referenced by compute_min_distance(), find_closest_point(), initialize(), max_distance(), and start().

---

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

• src/libigl/igl/exact_geodesic.cpp