QueryMethod.h

Go to the documentation of this file.

#ifndef PMPL_QUERY_METHOD_H_
#define PMPL_QUERY_METHOD_H_
 
#include "MapEvaluatorMethod.h"
 
#include "ConfigurationSpace/Path.h"
#include "MPProblem/MPProblem.h"
#include "MPProblem/MPTask.h"
#include "MPProblem/Robot/Robot.h"
#include "Utilities/SSSP.h"
 
 
class QueryMethod : virtual public MapEvaluatorMethod {
 
  public:
 
 
    typedef typename MPBaseObject::RoadmapType      RoadmapType;
    typedef typename RoadmapType::VID               VID;
    typedef typename RoadmapType::VertexSet         VertexSet;
    typedef std::unordered_set<size_t>              VIDSet;
 
 
    enum GraphSearchAlg {DIJKSTRAS, ASTAR}; 
 
 
    QueryMethod();
 
    QueryMethod(XMLNode& _node);
 
    virtual ~QueryMethod() = default;
 
 
    virtual void Print(std::ostream& _os) const override;
 
    virtual void Initialize() override;
 
 
    virtual bool operator()() override;
 
 
    std::vector<VID> GeneratePath(const VID _start, const VIDSet& _end);
 
    void SetDMLabel(const std::string& _dmLabel);
 
    virtual void SetPathWeightFunction(SSSPPathWeightFunction<RoadmapType> _f);
 
        void SetLastConstraintTime(double _last);
 
        void SetLastGoalConstraintTime(double _time);
 
        void SetStartTime(double _start);
 
        void SetEndTime(double _end);
 
 
  protected:
 
 
    virtual void Reset(RoadmapType* const _r);
 
    void SetSearchAlgViaString(std::string _alg, const std::string& _where);
 
    virtual bool PerformSubQuery(const VID _start, const VIDSet& _goal);
 
    virtual double StaticPathWeight(
        typename RoadmapType::adj_edge_iterator& _ei,
        const double _sourceDistance, const double _targetDistance) const;
 
    virtual double DynamicPathWeight(
        typename RoadmapType::adj_edge_iterator& _ei,
        const double _sourceDistance, const double _targetDistance) const;
 
    std::vector<typename QueryMethod::VID>
        TwoVariableQuery(const VID _start, const VIDSet& _goals);
 
 
    RoadmapType* m_roadmap{nullptr};   
    MPTask* m_task{nullptr};           
 
    size_t m_goalIndex{0};             
 
    GraphSearchAlg m_searchAlg{DIJKSTRAS};  
 
    std::string m_safeIntervalLabel; 
    std::string m_dmLabel;           
        bool m_twoVariable{false};       
 
    SSSPPathWeightFunction<RoadmapType> m_weightFunction;
 
        double m_lastConstraint{0};     
        double m_lastGoalConstraint{0}; 
        double m_startTime{0};          
        double m_endTime{0};            
 
 
};
 
#endif