NeighborhoodFinderMethod.h

Go to the documentation of this file.

#ifndef PMPL_NEIGHBORHOOD_FINDER_METHOD_H_
#define PMPL_NEIGHBORHOOD_FINDER_METHOD_H_
 
#include <boost/mpl/list.hpp>
#include <boost/mpl/for_each.hpp>
 
#include "Neighbors.h"
#include "MPLibrary/MPBaseObject.h"
#include "Utilities/MPUtils.h"
#include "ConfigurationSpace/GenericStateGraph.h"
 
 
class NeighborhoodFinderMethod : public MPBaseObject {
 
  public:
 
 
    typedef typename MPBaseObject::RoadmapType        RoadmapType;
    typedef typename RoadmapType::VID                 VID;
    typedef typename RoadmapType::VertexSet           VertexSet;
    typedef typename MPBaseObject::GroupRoadmapType   GroupRoadmapType;
    typedef typename MPBaseObject::GroupCfgType       GroupCfgType;
 
 
    enum class Type {
      K,       
      RADIUS,  
      APPROX,  
      OTHER    
    };
 
    typedef typename std::back_insert_iterator<std::vector<Neighbor>>
        OutputIterator;
 
 
    NeighborhoodFinderMethod(const Type _type = Type::OTHER);
 
    NeighborhoodFinderMethod(XMLNode& _node, const Type _type = Type::OTHER,
        const bool _requireDM = true);
 
    virtual ~NeighborhoodFinderMethod() = default;
 
 
    virtual void Print(std::ostream& _os) const override;
 
 
    Type GetType() const noexcept;
 
    virtual size_t& GetK() noexcept;
 
    virtual double& GetRadius() noexcept;
 
    virtual void SetDMLabel(const std::string& _label) noexcept;
 
    virtual const std::string& GetDMLabel() const noexcept;
 
 
    virtual void FindNeighbors(RoadmapType* const _r, const Cfg& _cfg,
        const VertexSet& _candidates, OutputIterator _out) = 0;
 
    virtual void FindNeighbors(GroupRoadmapType* const _r,
        const GroupCfgType& _cfg, const VertexSet& _candidates,
        OutputIterator _out) = 0;
 
    template <typename AbstractRoadmapType>
    void FindNeighbors(AbstractRoadmapType* const _r,
        const typename AbstractRoadmapType::CfgType& _cfg, OutputIterator _out);
 
 
  protected:
 
 
    template <typename AbstractRoadmapType>
    bool DirectEdge(const AbstractRoadmapType* _g,
        const typename AbstractRoadmapType::CfgType& _c,
        const typename AbstractRoadmapType::VID _v) const noexcept;
 
 
    Type m_nfType{Type::OTHER}; 
    size_t m_k{0};              
    double m_radius{0};         
 
    std::string m_dmLabel;      
    bool m_unconnected{false};  
 
 
};
 
/*------------------------ Nearest-Neighbor Queries --------------------------*/
 
template <typename AbstractRoadmapType>
void
NeighborhoodFinderMethod::
FindNeighbors(AbstractRoadmapType* const _r,
    const typename AbstractRoadmapType::CfgType& _cfg,
    OutputIterator _out) {
  this->FindNeighbors(_r, _cfg, _r->GetAllVIDs(), _out);
}
 
/*-------------------------------- Helpers -----------------------------------*/
 
template <typename AbstractRoadmapType>
inline
bool
NeighborhoodFinderMethod::
DirectEdge(const AbstractRoadmapType* _g,
    const typename AbstractRoadmapType::CfgType& _c,
    const typename AbstractRoadmapType::VID _v) const noexcept {
  // The nodes are neighbors if _c is in the graph and the edge (_c, _v) exists.
  const typename AbstractRoadmapType::VID vid = _g->GetVID(_c);
  return vid != INVALID_VID and _g->IsEdge(vid, _v);
}
 
#endif