versions/main/_cartesian_wrench_8hpp_source.html

#pragma once


#include "state_representation/space/cartesian/CartesianState.hpp"

#include "state_representation/space/cartesian/CartesianPose.hpp"

#include "state_representation/space/cartesian/CartesianTwist.hpp"

#include "state_representation/space/cartesian/CartesianAcceleration.hpp"


namespace state_representation {


class CartesianPose;

class CartesianTwist;

class CartesianAcceleration;


class CartesianWrench : public CartesianState {

public:

  // delete inaccessible getter and setters

  const Eigen::Vector3d& get_linear_velocity() const = delete;

  const Eigen::Vector3d& get_angular_velocity() const = delete;

  Eigen::Matrix<double, 6, 1> get_twist() const = delete;

  const Eigen::Vector3d& get_position() const = delete;

  const Eigen::Quaterniond& get_orientation() const = delete;

  Eigen::Vector4d get_orientation_coefficients() const = delete;

  Eigen::Matrix<double, 7, 1> get_pose() const = delete;

  Eigen::Matrix4d get_transformation_matrix() const = delete;

  const Eigen::Vector3d& get_linear_acceleration() const = delete;

  const Eigen::Vector3d& get_angular_acceleration() const = delete;

  Eigen::Matrix<double, 6, 1> get_acceleration() const = delete;

  void set_position(const Eigen::Vector3d& position) = delete;

  void set_position(const std::vector<double>& position) = delete;

  void set_position(const double& x, const double& y, const double& z) = delete;

  void set_orientation(const Eigen::Quaterniond& orientation) = delete;

  void set_orientation(const Eigen::Vector4d& orientation) = delete;

  void set_orientation(const std::vector<double>& orientation) = delete;

  void set_orientation(const double& w, const double& x, const double& y, const double& z) = delete;

  void set_pose(const Eigen::Vector3d& position, const Eigen::Quaterniond& orientation) = delete;

  void set_pose(const Eigen::Matrix<double, 7, 1>& pose) = delete;

  void set_pose(const std::vector<double>& pose) = delete;

  void set_linear_velocity(const Eigen::Vector3d& linear_velocity) = delete;

  void set_linear_velocity(const std::vector<double>& linear_velocity) = delete;

  void set_linear_velocity(const double& x, const double& y, const double& z) = delete;

  void set_angular_velocity(const Eigen::Vector3d& angular_velocity) = delete;

  void set_angular_velocity(const std::vector<double>& angular_velocity) = delete;

  void set_angular_velocity(const double& x, const double& y, const double& z) = delete;

  void set_twist(const Eigen::Matrix<double, 6, 1>& twist) = delete;

  void set_twist(const std::vector<double>& twist) = delete;

  void set_linear_acceleration(const Eigen::Vector3d& linear_acceleration) = delete;

  void set_linear_acceleration(const std::vector<double>& linear_acceleration) = delete;

  void set_linear_acceleration(const double& x, const double& y, const double& z) = delete;

  void set_angular_acceleration(const Eigen::Vector3d& angular_acceleration) = delete;

  void set_angular_acceleration(const std::vector<double>& angular_acceleration) = delete;

  void set_angular_acceleration(const double& x, const double& y, const double& z) = delete;

  void set_acceleration(const Eigen::Matrix<double, 6, 1>& acceleration) = delete;

  void set_acceleration(const std::vector<double>& acceleration) = delete;

  CartesianState inverse() const = delete;

  CartesianState& operator*=(const CartesianState& state) = delete;

  CartesianState operator*(const CartesianState& state) const = delete;

  Eigen::Vector3d operator*(const Eigen::Vector3d& vector) const = delete;

  CartesianState& operator+=(const CartesianPose& pose) = delete;

  CartesianState& operator+=(const CartesianTwist& twist) = delete;

  CartesianState& operator+=(const CartesianAcceleration& acceleration) = delete;

  CartesianState operator+(const CartesianPose& pose) const = delete;

  CartesianState operator+(const CartesianTwist& twist) const = delete;

  CartesianState operator+(const CartesianAcceleration& acceleration) const = delete;

  CartesianState& operator-=(const CartesianPose& pose) = delete;

  CartesianState& operator-=(const CartesianTwist& twist) = delete;

  CartesianState& operator-=(const CartesianAcceleration& acceleration) = delete;

  CartesianState operator-(const CartesianPose& pose) const = delete;

  CartesianState operator-(const CartesianTwist& twist) const = delete;

  CartesianState operator-(const CartesianAcceleration& acceleration) const = delete;


  explicit CartesianWrench();


  explicit CartesianWrench(const std::string& name, const std::string& reference = "world");


  CartesianWrench(const CartesianWrench& wrench);


  CartesianWrench(const CartesianState& state);


  explicit CartesianWrench(

      const std::string& name, const Eigen::Vector3d& force, const std::string& reference = "world"

  );


  explicit CartesianWrench(

      const std::string& name, const Eigen::Vector3d& force, const Eigen::Vector3d& torque,

      const std::string& reference = "world"

  );


  explicit CartesianWrench(

      const std::string& name, const Eigen::Matrix<double, 6, 1>& wrench, const std::string& reference = "world"

  );


  static CartesianWrench Zero(const std::string& name, const std::string& reference = "world");


  static CartesianWrench Random(const std::string& name, const std::string& reference = "world");


  CartesianWrench& operator=(const CartesianWrench& wrench) = default;


  Eigen::VectorXd data() const override;


  void set_data(const Eigen::VectorXd& data) override;


  void set_data(const std::vector<double>& data) override;


  void clamp(double max_force, double max_torque, double force_noise_ratio = 0, double torque_noise_ratio = 0);


  CartesianWrench clamped(

      double max_force, double max_torque, double force_noise_ratio = 0, double torque_noise_ratio = 0

  ) const;


  CartesianWrench copy() const;


  CartesianWrench normalized(const CartesianStateVariable& state_variable_type = CartesianStateVariable::WRENCH) const;


  std::vector<double>

  norms(const CartesianStateVariable& state_variable_type = CartesianStateVariable::WRENCH) const override;


  CartesianWrench& operator*=(double lambda);


  CartesianWrench operator*(double lambda) const;


  friend CartesianWrench operator*(double lambda, const CartesianWrench& wrench);


  friend CartesianWrench

  operator*(const Eigen::Matrix<double, 6, 6>& lambda, const CartesianWrench& wrench);


  CartesianWrench& operator/=(double lambda);


  CartesianWrench operator/(double lambda) const;


  CartesianWrench& operator+=(const CartesianWrench& wrench);


  CartesianWrench& operator+=(const CartesianState& state);


  CartesianWrench operator+(const CartesianWrench& wrench) const;


  CartesianState operator+(const CartesianState& state) const;


  CartesianWrench operator-() const;


  CartesianWrench& operator-=(const CartesianWrench& wrench);


  CartesianWrench& operator-=(const CartesianState& state);


  CartesianWrench operator-(const CartesianWrench& wrench) const;


  CartesianState operator-(const CartesianState& state) const;


  friend std::ostream& operator<<(std::ostream& os, const CartesianWrench& wrench);


private:

  using CartesianState::clamp_state_variable;

};


}// namespace state_representation

state_representation::CartesianAcceleration
Class to define acceleration in Cartesian space as 3D linear and angular acceleration vectors.
Definition CartesianAcceleration.hpp:18

state_representation::CartesianPose
Class to define Cartesian pose in Cartesian space as 3D position and quaternion based orientation.
Definition CartesianPose.hpp:18

state_representation::CartesianState
Class to represent a state in Cartesian space.
Definition CartesianState.hpp:48

state_representation::CartesianState::clamp_state_variable
void clamp_state_variable(double max_norm, const CartesianStateVariable &state_variable_type, double noise_ratio=0)
Clamp inplace the norm of the a specific state variable.
Definition CartesianState.cpp:449

state_representation::CartesianTwist
Class to define twist in Cartesian space as 3D linear and angular velocity vectors.
Definition CartesianTwist.hpp:18

state_representation::CartesianWrench
Class to define wrench in Cartesian space as 3D force and torque vectors.
Definition CartesianWrench.hpp:18

state_representation::CartesianWrench::data
Eigen::VectorXd data() const override
Returns the wrench data as an Eigen vector.
Definition CartesianWrench.cpp:59

state_representation::CartesianWrench::operator*
friend CartesianWrench operator*(double lambda, const CartesianWrench &wrench)
Scale a Cartesian wrench by a scalar.
Definition CartesianWrench.cpp:108

state_representation::CartesianWrench::CartesianWrench
CartesianWrench()
Empty constructor.
Definition CartesianWrench.cpp:8

state_representation::CartesianWrench::normalized
CartesianWrench normalized(const CartesianStateVariable &state_variable_type=CartesianStateVariable::WRENCH) const
Compute the normalized wrench at the state variable given in argument (default is full wrench)
Definition CartesianWrench.cpp:95

state_representation::CartesianWrench::operator/
CartesianWrench operator/(double lambda) const
Scale a Cartesian wrench by a scalar.
Definition CartesianWrench.cpp:127

state_representation::CartesianWrench::Zero
static CartesianWrench Zero(const std::string &name, const std::string &reference="world")
Constructor for the zero wrench.
Definition CartesianWrench.cpp:49

state_representation::CartesianWrench::set_data
void set_data(const Eigen::VectorXd &data) override
Set the wrench data from an Eigen vector.
Definition CartesianWrench.cpp:63

state_representation::CartesianWrench::clamped
CartesianWrench clamped(double max_force, double max_torque, double force_noise_ratio=0, double torque_noise_ratio=0) const
Return the clamped wrench.
Definition CartesianWrench.cpp:82

state_representation::CartesianWrench::norms
std::vector< double > norms(const CartesianStateVariable &state_variable_type=CartesianStateVariable::WRENCH) const override
Compute the norms of the state variable specified by the input type (default is full wrench)
Definition CartesianWrench.cpp:99

state_representation::CartesianWrench::operator=
CartesianWrench & operator=(const CartesianWrench &wrench)=default
Copy assignment operator that has to be defined to the custom assignment operator.

state_representation::CartesianWrench::copy
CartesianWrench copy() const
Return a copy of the Cartesian wrench.
Definition CartesianWrench.cpp:90

state_representation::CartesianWrench::operator<<
friend std::ostream & operator<<(std::ostream &os, const CartesianWrench &wrench)
Overload the ostream operator for printing.
Definition CartesianWrench.cpp:171

state_representation::CartesianWrench::operator-
CartesianWrench operator-() const
Negate a Cartesian wrench.
Definition CartesianWrench.cpp:149

state_representation::CartesianWrench::clamp
void clamp(double max_force, double max_torque, double force_noise_ratio=0, double torque_noise_ratio=0)
Clamp inplace the magnitude of the wrench to the values in argument.
Definition CartesianWrench.cpp:75

state_representation::CartesianWrench::operator/=
CartesianWrench & operator/=(double lambda)
Scale inplace by a scalar.
Definition CartesianWrench.cpp:122

state_representation::CartesianWrench::Random
static CartesianWrench Random(const std::string &name, const std::string &reference="world")
Constructor for a random wrench.
Definition CartesianWrench.cpp:53

state_representation
Core state variables and objects.
Definition AnalogIOState.hpp:5