Inheritance diagram for igl::geodesic::IntervalWithStop:

Collaboration diagram for igl::geodesic::IntervalWithStop:

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

Public Member Functions
double &	stop ()

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	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_stop

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

inherited

Enumerator
FROM_FACE_0
FROM_FACE_1
FROM_SOURCE
UNDEFINED_DIRECTION

    {
        FROM_FACE_0,
    FROM_FACE_1,
    FROM_SOURCE,
    UNDEFINED_DIRECTION
    };

Member Function Documentation

◆ compute_min_distance()

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

inlineinherited

  {
    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, igl::geodesic::Interval::m_d, igl::geodesic::Interval::m_min, igl::geodesic::Interval::m_pseudo_x, igl::geodesic::Interval::m_pseudo_y, igl::geodesic::Interval::m_start, igl::geodesic::Interval::signal(), and igl::geodesic::Interval::stop().

Referenced by igl::geodesic::Interval::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 ( )

inlineinherited

1301{return m_d;};

References igl::geodesic::Interval::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 ( )

inlineinherited

1307{return m_direction;};

igl::geodesic::Interval::m_direction

DirectionType m_direction

Definition exact_geodesic.cpp:1325

References igl::geodesic::Interval::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 ( )

inlineinherited

1306{return m_edge;};

igl::geodesic::Interval::m_edge

edge_pointer m_edge

Definition exact_geodesic.cpp:1323

References igl::geodesic::Interval::m_edge.

Referenced by igl::geodesic::GeodesicAlgorithmExact::construct_propagated_intervals(), igl::geodesic::Interval::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
	)

inlineinherited

  {
    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, igl::geodesic::Interval::hypotenuse(), igl::geodesic::Edge::length(), igl::geodesic::Interval::m_d, igl::geodesic::Interval::m_edge, igl::geodesic::Interval::m_pseudo_x, igl::geodesic::Interval::m_pseudo_y, igl::geodesic::Interval::m_start, igl::geodesic::Interval::signal(), igl::geodesic::SMALLEST_INTERVAL_RATIO, and igl::geodesic::Interval::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
	)

inlineinherited

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

References sqrt().

Referenced by igl::geodesic::Interval::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`
	)

inlineinherited

{
  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());
} 

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 )

inlineinherited

  {
    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, igl::geodesic::Interval::m_d, igl::geodesic::Interval::m_pseudo_x, igl::geodesic::Interval::m_pseudo_y, igl::geodesic::Interval::m_start, and sqrt().

Here is the call graph for this function:

◆ min()

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

inlineinherited

1304{return m_min;};

References igl::geodesic::Interval::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 ( )

inlineinherited

1305{return m_next;};

References igl::geodesic::Interval::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

inlineinherited

  {
    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 ( )

inlineinherited

1302{return m_pseudo_x;};

References igl::geodesic::Interval::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 ( )

inlineinherited

1303{return m_pseudo_y;};

References igl::geodesic::Interval::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 )

inlineinherited

  {
    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);
      }
    }
  }