discrete_event.hpp

Go to the documentation of this file.

#ifndef ROBOTOC_DISCRETE_EVENT_HPP_
#define ROBOTOC_DISCRETE_EVENT_HPP_
 
#include <vector>
 
#include "robotoc/robot/contact_status.hpp"
#include "robotoc/robot/impact_status.hpp"
 
 
namespace robotoc {
 
enum class DiscreteEventType {
  Impact,
  Lift,
  None
};
 
class DiscreteEvent {
public:
  DiscreteEvent(const ContactStatus& pre_contact_status, 
                const ContactStatus& post_contact_status);
 
  DiscreteEvent();
 
  ~DiscreteEvent() = default;
 
  DiscreteEvent(const DiscreteEvent&) = default;
 
  DiscreteEvent& operator=(const DiscreteEvent&) = default;
 
  DiscreteEvent(DiscreteEvent&&) noexcept = default;
 
  DiscreteEvent& operator=(DiscreteEvent&&) noexcept = default;
 
  bool existDiscreteEvent() const {
    return (exist_impact_ || exist_lift_);
  }
 
  bool existImpact() const {
    return exist_impact_;
  }
 
  bool existLift() const {
    return exist_lift_;
  }
 
  const ImpactStatus& impactStatus() const {
    return impact_status_;
  }
 
  const ContactStatus& preContactStatus() const {
    return pre_contact_status_;
  }
 
  const ContactStatus& postContactStatus() const {
    return post_contact_status_;
  }
 
  void setDiscreteEvent(const ContactStatus& pre_contact_status, 
                        const ContactStatus& post_contact_status);
 
  void setContactPlacement(const int contact_index, 
                           const Eigen::Vector3d& contact_position);
 
  void setContactPlacement(const int contact_index, 
                           const Eigen::Vector3d& contact_position, 
                           const Eigen::Matrix3d& contact_rotation);
 
  void setContactPlacements(
      const std::vector<Eigen::Vector3d>& contact_positions);
 
  void setContactPlacements(
      const std::vector<Eigen::Vector3d>& contact_positions,
      const std::vector<Eigen::Matrix3d>& contact_rotations);
 
  void setContactPlacements(const aligned_vector<SE3>& contact_placements);
 
 
  void setFrictionCoefficient(const int contact_index, 
                              const double friction_coefficient);
 
  void setFrictionCoefficients(const std::vector<double>& friction_coefficients);
 
  int maxNumContacts() const {
    return max_num_contacts_;
  }
 
  DiscreteEventType eventType() const {
    return event_type_;
  }
 
  void disp(std::ostream& os) const;
 
  friend std::ostream& operator<<(std::ostream& os, 
                                  const DiscreteEvent& discrete_event);
 
private:
  ContactStatus pre_contact_status_, post_contact_status_;
  ImpactStatus impact_status_;
  int max_num_contacts_;
  DiscreteEventType event_type_;
  bool exist_impact_, exist_lift_;
 
};
 
} // namespace robotoc
 
#endif // ROBOTOC_DISCRETE_EVENT_HPP_