Inheritance diagram for pgrouting::algorithms::Pgr_astar< G >::distance_heuristic:

Collaboration diagram for pgrouting::algorithms::Pgr_astar< G >::distance_heuristic:

Public Member Functions
	distance_heuristic (B_G &g, const std::vector< V > &goals, int heuristic, double factor)

	distance_heuristic (B_G &g, V goal, int heuristic, double factor)

double	operator() (V u)

Private Attributes
double	m_factor

B_G &	m_g

std::set< V >	m_goals

int	m_heuristic

Detailed Description

template<class G>
class pgrouting::algorithms::Pgr_astar< G >::distance_heuristic

Definition at line 216 of file pgr_astar.hpp.

Constructor & Destructor Documentation

◆ distance_heuristic() [1/2]

template<class G >

pgrouting::algorithms::Pgr_astar< G >::distance_heuristic::distance_heuristic	(	B_G &	g,
		V	goal,
		int	heuristic,
		double	factor
	)

inline

Definition at line 218 of file pgr_astar.hpp.

               : m_g(g),
               m_factor(factor),
               m_heuristic(heuristic) {
                   m_goals.insert(goal);
               }

References pgrouting::algorithms::Pgr_astar< G >::distance_heuristic::m_goals.

◆ distance_heuristic() [2/2]

template<class G >

pgrouting::algorithms::Pgr_astar< G >::distance_heuristic::distance_heuristic	(	B_G &	g,
		const std::vector< V > &	goals,
		int	heuristic,
		double	factor
	)

inline

Definition at line 224 of file pgr_astar.hpp.

               : m_g(g),
               m_goals(goals.begin(), goals.end()),
               m_factor(factor),
               m_heuristic(heuristic) {}

Member Function Documentation

◆ operator()()

template<class G >

double pgrouting::algorithms::Pgr_astar< G >::distance_heuristic::operator() ( V u )

inline

Definition at line 234 of file pgr_astar.hpp.

                                  {
               if (m_heuristic == 0) return 0;
               if (m_goals.empty()) return 0;
               double best_h((std::numeric_limits<double>::max)());
               for (auto goal : m_goals) {
                   double current((std::numeric_limits<double>::max)());
                   double dx = m_g[goal].x() - m_g[u].x();
                   double dy = m_g[goal].y() - m_g[u].y();
                   switch (m_heuristic) {
                       case 0:
                           current = 0;
                           break;
                       case 1:
                           current = std::fabs((std::max)(dx, dy)) * m_factor;
                           break;
                       case 2:
                           current = std::fabs((std::min)(dx, dy)) * m_factor;
                           break;
                       case 3:
                           current = (dx * dx + dy * dy) * m_factor * m_factor;
                           break;
                       case 4:
                           current = std::sqrt(dx * dx + dy * dy) * m_factor;
                           break;
                       case 5:
                           current = (std::fabs(dx) + std::fabs(dy)) * m_factor;
                           break;
                       default:
                           current = 0;
                   }
                   if (current < best_h) {
                       best_h = current;
                   }
               }
               {
                   auto s_it = m_goals.find(u);
                   if (!(s_it == m_goals.end())) {
                       // found one more goal
                       m_goals.erase(s_it);
                   }
               }
               return best_h;
           }