StraightLine.h

Go to the documentation of this file.

#ifndef PMPL_STRAIGHT_LINE_H_
#define PMPL_STRAIGHT_LINE_H_
 
#include "ConfigurationSpace/GroupRoadmap.h"
 
#include "GroupLPOutput.h"
#include "LPOutput.h"
#include "LocalPlannerMethod.h"
 
class StraightLine : virtual public LocalPlannerMethod {
 public:
 
  typedef typename MPBaseObject::WeightType WeightType;
  typedef typename MPBaseObject::GroupCfgType GroupCfgType;
  typedef typename MPBaseObject::GroupRoadmapType GroupRoadmapType;
  typedef typename GroupCfgType::Formation Formation;
 
 
  StraightLine(const std::string& _vcLabel = "",
               bool _binary = false,
               bool _saveIntermediates = false);
 
  StraightLine(XMLNode& _node);
 
  virtual ~StraightLine() = default;
 
 
  virtual void Print(std::ostream& _os) const override;
 
 
  virtual bool IsConnected(const Cfg& _c1,
                           const Cfg& _c2,
                           Cfg& _col,
                           LPOutput* _lpOutput,
                           double _positionRes,
                           double _orientationRes,
                           bool _checkCollision = true,
                           bool _savePath = false) override;
 
  virtual bool IsConnected(
      const GroupCfgType& _c1,
      const GroupCfgType& _c2,
      GroupCfgType& _col,
      GroupLPOutput* _lpOutput,
      double _positionRes,
      double _orientationRes,
      bool _checkCollision = true,
      bool _savePath = false,
      const Formation& _robotIndexes = Formation()) override;
 
 
 protected:
 
  bool IsConnectedFunc(const Cfg& _c1,
                       const Cfg& _c2,
                       Cfg& _col,
                       LPOutput* _lpOutput,
                       double _positionRes,
                       double _orientationRes,
                       bool _checkCollision = true,
                       bool _savePath = false);
 
  virtual bool IsConnectedEqualVelocities(const GroupCfgType& _c1,
                                          const GroupCfgType& _c2,
                                          GroupCfgType& _col,
                                          GroupLPOutput* _lpOutput,
                                          double _positionRes,
                                          double _orientationRes,
                                          bool _checkCollision,
                                          bool _savePath,
                                          const Formation& _robotIndexes);
 
  virtual bool IsConnectedSLSequential(const Cfg& _c1,
                                       const Cfg& _c2,
                                       Cfg& _col,
                                       LPOutput* _lpOutput,
                                       int& _cdCounter,
                                       double _positionRes,
                                       double _orientationRes,
                                       bool _checkCollision = true,
                                       bool _savePath = false);
 
  virtual bool IsConnectedSLBinary(const Cfg& _c1,
                                   const Cfg& _c2,
                                   Cfg& _col,
                                   LPOutput* _lpOutput,
                                   int& _cdCounter,
                                   double _positionRes,
                                   double _orientationRes,
                                   bool _checkCollision = true,
                                   bool _savePath = false);
 
 
  std::string m_dmLabel;           
  std::string m_vcLabel;           
  bool m_binaryEvaluation{false};  
  bool m_equalVelocity{false};  
 
  double m_selfEdgeSteps{1};
 
};
 
#endif