CartesianAcceleration.hpp

#pragma once
 
#include "state_representation/space/cartesian/CartesianState.hpp"
#include "state_representation/space/cartesian/CartesianTwist.hpp"
 
namespace state_representation {
class CartesianTwist;
 
class CartesianAcceleration : public CartesianState {
private:
  using CartesianState::clamp_state_variable;
 
public:
  // delete inaccessible getter and setters
  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_velocity() const = delete;
  const Eigen::Vector3d& get_angular_velocity() const = delete;
  Eigen::Matrix<double, 6, 1> get_twist() const = delete;
  const Eigen::Vector3d& get_force() const = delete;
  const Eigen::Vector3d& get_torque() const = delete;
  Eigen::Matrix<double, 6, 1> get_wrench() 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_force(const Eigen::Vector3d& force) = delete;
  void set_force(const std::vector<double>& force) = delete;
  void set_force(const double& x, const double& y, const double& z) = delete;
  void set_torque(const Eigen::Vector3d& torque) = delete;
  void set_torque(const std::vector<double>& torque) = delete;
  void set_torque(const double& x, const double& y, const double& z) = delete;
  void set_wrench(const Eigen::Matrix<double, 6, 1>& wrench) = delete;
  void set_wrench(const std::vector<double>& wrench) = delete;
  CartesianState operator*=(const CartesianState& state) = delete;
  CartesianState operator*(const CartesianState& state) = delete;
  friend CartesianState operator*=(const CartesianState& state, const CartesianAcceleration& acceleration) = delete;
 
  explicit CartesianAcceleration();
 
  explicit CartesianAcceleration(const std::string& name, const std::string& reference = "world");
 
  CartesianAcceleration(const CartesianAcceleration& acceleration);
 
  CartesianAcceleration(const CartesianState& state);
 
  CartesianAcceleration(const CartesianTwist& pose);
 
  explicit CartesianAcceleration(
      const std::string& name, const Eigen::Vector3d& linear_acceleration, const std::string& reference = "world"
  );
 
  explicit CartesianAcceleration(
      const std::string& name, const Eigen::Vector3d& linear_acceleration, const Eigen::Vector3d& angular_acceleration,
      const std::string& reference = "world"
  );
 
  explicit CartesianAcceleration(
      const std::string& name, const Eigen::Matrix<double, 6, 1>& acceleration, const std::string& reference = "world"
  );
 
  static CartesianAcceleration Zero(const std::string& name, const std::string& reference = "world");
 
  static CartesianAcceleration Random(const std::string& name, const std::string& reference = "world");
 
  CartesianAcceleration& operator=(const CartesianAcceleration& acceleration) = default;
 
  CartesianAcceleration& operator+=(const CartesianAcceleration& acceleration);
 
  CartesianAcceleration operator+(const CartesianAcceleration& acceleration) const;
 
  CartesianAcceleration& operator-=(const CartesianAcceleration& acceleration);
 
  CartesianAcceleration operator-(const CartesianAcceleration& acceleration) const;
 
  CartesianAcceleration& operator*=(double lambda);
 
  CartesianAcceleration operator*(double lambda) const;
 
  CartesianAcceleration& operator/=(double lambda);
 
  CartesianAcceleration operator/(double lambda) const;
 
  CartesianAcceleration& operator*=(const Eigen::Matrix<double, 6, 6>& lambda);
 
  CartesianTwist operator*(const std::chrono::nanoseconds& dt) const;
 
  void clamp(double max_linear, double max_angular, double linear_noise_ratio = 0, double angular_noise_ratio = 0);
 
  CartesianAcceleration clamped(
      double max_linear, double max_angular, double noise_ratio = 0, double angular_noise_ratio = 0
  ) const;
 
  CartesianAcceleration copy() const;
 
  Eigen::VectorXd data() const override;
 
  void set_data(const Eigen::VectorXd& data) override;
 
  void set_data(const std::vector<double>& data) override;
 
  CartesianAcceleration inverse() const;
 
  std::vector<double>
  norms(const CartesianStateVariable& state_variable_type = CartesianStateVariable::ACCELERATION) const override;
 
  CartesianAcceleration
  normalized(const CartesianStateVariable& state_variable_type = CartesianStateVariable::ACCELERATION) const;
 
  friend std::ostream& operator<<(std::ostream& os, const CartesianAcceleration& acceleration);
 
  friend CartesianAcceleration operator*(const CartesianState& state, const CartesianAcceleration& acceleration);
 
  friend CartesianAcceleration operator*(double lambda, const CartesianAcceleration& acceleration);
 
  friend CartesianAcceleration
  operator*(const Eigen::Matrix<double, 6, 6>& lambda, const CartesianAcceleration& acceleration);
 
  friend CartesianTwist operator*(const std::chrono::nanoseconds& dt, const CartesianAcceleration& acceleration);
};
 
inline std::vector<double> CartesianAcceleration::norms(const CartesianStateVariable& state_variable_type) const {
  return CartesianState::norms(state_variable_type);
}
 
inline CartesianAcceleration CartesianAcceleration::normalized(const CartesianStateVariable& state_variable_type) const {
  return CartesianState::normalized(state_variable_type);
}
}// namespace state_representation