CartesianWrench.hpp

#pragma once
 
#include "state_representation/space/cartesian/CartesianState.hpp"
#include "state_representation/space/cartesian/CartesianPose.hpp"
#include "state_representation/space/cartesian/CartesianTwist.hpp"
 
namespace state_representation {
class CartesianPose;
class CartesianTwist;
class CartesianWrench : public CartesianState {
private:
  using CartesianState::clamp_state_variable;
 
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 operator*=(const CartesianState& state) = delete;
  CartesianState operator*(const CartesianState& state) = delete;
  friend CartesianState operator*=(const CartesianState& state, const CartesianWrench& wrench) = 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;
 
  CartesianWrench& operator+=(const CartesianWrench& wrench);
 
  CartesianWrench operator+(const CartesianWrench& wrench) const;
 
  CartesianWrench& operator-=(const CartesianWrench& wrench);
 
  CartesianWrench operator-(const CartesianWrench& wrench) const;
 
  CartesianWrench& operator*=(double lambda);
 
  CartesianWrench operator*(double lambda) const;
 
  CartesianWrench& operator/=(double lambda);
 
  CartesianWrench operator/(double lambda) const;
 
  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;
 
  Eigen::VectorXd data() const override;
 
  void set_data(const Eigen::VectorXd& data) override;
 
  void set_data(const std::vector<double>& data) override;
 
  CartesianWrench inverse() const;
 
  std::vector<double>
  norms(const CartesianStateVariable& state_variable_type = CartesianStateVariable::WRENCH) const override;
 
  CartesianWrench normalized(const CartesianStateVariable& state_variable_type = CartesianStateVariable::WRENCH) const;
 
  friend std::ostream& operator<<(std::ostream& os, const CartesianWrench& wrench);
 
  friend CartesianWrench operator*(const CartesianState& state, const CartesianWrench& wrench);
 
  friend CartesianWrench operator*(double lambda, const CartesianWrench& wrench);
};
 
inline std::vector<double> CartesianWrench::norms(const CartesianStateVariable& state_variable_type) const {
  return CartesianState::norms(state_variable_type);
}
 
inline CartesianWrench CartesianWrench::normalized(const CartesianStateVariable& state_variable_type) const {
  return CartesianState::normalized(state_variable_type);
}
}// namespace state_representation