Nodes.hpp

Go to the documentation of this file.

 
#ifndef NODES_HPP
#define NODES_HPP
 
#include "../GeospatialOperations.hpp"
 
// Put implicit includes in here.
 
 
 
namespace pathplanners
{
 
    namespace nodes
    {
 
 
        struct AStarNode
        {
            public:
                // Declare struct public member variables.
                std::shared_ptr<AStarNode> pParentNode;    // A shared pointer to the parent node the this nodes comes after in the path.
                geoops::UTMCoordinate stNodeLocation;      // The global position of this point/node stored in UTM format.
                double dKg;                                // The cost of the path from the star node to the current node.
                double dKh;                                // The heuristic estimate of how much it will cost to get to the end node.
                double dKf;                                // The sum of dKg and dKh. An estimate for the total cost of the node.
 
 
                AStarNode(std::shared_ptr<AStarNode> pParentNode     = nullptr,
                          const geoops::UTMCoordinate stNodeLocation = geoops::UTMCoordinate(),
                          const double dKg                           = 0.0,
                          const double dKh                           = 0.0,
                          const double dKf                           = 0.0)
                {
                    // Initialize struct member variables.
                    this->pParentNode    = pParentNode;
                    this->stNodeLocation = stNodeLocation;
                    this->dKg            = dKg;
                    this->dKh            = dKh;
                    this->dKf            = dKf;
                }
 
 
                bool operator<(const AStarNode& other) const { return this->dKf < other.dKf; }
 
 
                bool operator<=(const AStarNode& other) const { return this->dKf <= other.dKf; }
 
 
                bool operator>(const AStarNode& other) const { return this->dKf > other.dKf; }
 
 
                bool operator>=(const AStarNode& other) const { return this->dKf >= other.dKf; }
 
 
                bool operator==(const AStarNode& other) const
                {
                    return this->stNodeLocation.dEasting == other.stNodeLocation.dEasting && this->stNodeLocation.dNorthing == other.stNodeLocation.dNorthing;
                }
        };
    }    // namespace nodes
}    // namespace pathplanners
 
#endif