31 #include <pybind11/eigen.h> 32 #include <pybind11/pybind11.h> 33 #include <pybind11/stl.h> 60 module.doc() =
"Exotica task map definitions";
62 py::module::import(
"pyexotica");
64 py::class_<ControlRegularization, std::shared_ptr<ControlRegularization>,
TaskMap>(module,
"ControlRegularization")
68 py::class_<EffFrame, std::shared_ptr<EffFrame>,
TaskMap>(module,
"EffFrame")
71 py::class_<EffPosition, std::shared_ptr<EffPosition>, TaskMap>(module,
"EffPosition");
73 py::class_<EffOrientation, std::shared_ptr<EffOrientation>, TaskMap>(module,
"EffOrientation")
76 py::class_<EffAxisAlignment, std::shared_ptr<EffAxisAlignment>, TaskMap>(module,
"EffAxisAlignment")
82 py::class_<EffBox, std::shared_ptr<EffBox>, TaskMap>(module,
"EffBox")
86 py::class_<PointToLine, std::shared_ptr<PointToLine>, TaskMap>(module,
"PointToLine")
89 py::class_<JointVelocityLimitConstraint, std::shared_ptr<JointVelocityLimitConstraint>, TaskMap>(module,
"JointVelocityLimitConstraint")
92 py::class_<JointVelocityBackwardDifference, std::shared_ptr<JointVelocityBackwardDifference>, TaskMap>(module,
"JointVelocityBackwardDifference")
95 py::class_<JointAccelerationBackwardDifference, std::shared_ptr<JointAccelerationBackwardDifference>, TaskMap>(module,
"JointAccelerationBackwardDifference")
98 py::class_<JointJerkBackwardDifference, std::shared_ptr<JointJerkBackwardDifference>, TaskMap>(module,
"JointJerkBackwardDifference")
101 py::class_<CenterOfMass, std::shared_ptr<CenterOfMass>, TaskMap>(module,
"CenterOfMass");
103 py::class_<Distance, std::shared_ptr<Distance>, TaskMap>(module,
"Distance");
105 py::class_<JointPose, std::shared_ptr<JointPose>, TaskMap>(module,
"JointPose")
109 py::class_<JointTorqueMinimizationProxy, std::shared_ptr<JointTorqueMinimizationProxy>, TaskMap>(module,
"JointTorqueMinimizationProxy")
112 py::class_<InteractionMesh, std::shared_ptr<InteractionMesh>, TaskMap>(module,
"InteractionMesh")
115 .def_static(
"compute_goal_laplace", [](
const std::vector<KDL::Frame>& nodes,
Eigen::MatrixXdRefConst weights) {
116 Eigen::VectorXd goal;
124 py::class_<JointLimit, std::shared_ptr<JointLimit>, TaskMap>(module,
"JointLimit");
126 py::class_<SphereCollision, std::shared_ptr<SphereCollision>, TaskMap>(module,
"SphereCollision");
128 py::class_<CollisionDistance, std::shared_ptr<CollisionDistance>, TaskMap>(module,
"CollisionDistance")
Eigen::Matrix< double, 6, 1 > get_h() const
void SetDirection(const std::string &frame_name, const Eigen::Vector3d &dir_in)
const Eigen::VectorXd & get_joint_ref() const
void SetPreviousJointState(Eigen::VectorXdRefConst joint_state)
Logs current joint state. SetPreviousJointState must be called after solve is called in a Python/C++ ...
void SetWeight(int i, int j, double weight)
void set_h(const Eigen::Matrix< double, 6, 1 > &h_in)
const RotationType & get_rotation_type() const
Eigen::MatrixXd GetWeights()
Eigen::Vector3d GetAxis(const std::string &frame_name) const
const RotationType & get_rotation_type() const
const std::vector< int > & get_joint_map() const
Eigen::Vector3d GetDirection(const std::string &frame_name) const
void set_joint_ref(Eigen::VectorXdRefConst ref)
const Eigen::Ref< const Eigen::MatrixXd > & MatrixXdRefConst
void SetPreviousJointState(Eigen::VectorXdRefConst joint_state)
Logs previous joint state. SetPreviousJointState must be called after solve is called in a Python/C++...
void SetAxis(const std::string &frame_name, const Eigen::Vector3d &axis_in)
PYBIND11_MODULE(exotica_core_task_maps_py, module)
Eigen::Vector3d GetUpperLimit(const int eff_id) const
void SetWeights(const Eigen::MatrixXd &weights)
const Eigen::Ref< const Eigen::VectorXd > & VectorXdRefConst
void SetPreviousJointState(Eigen::VectorXdRefConst joint_state)
Logs previous joint state. SetPreviousJointState must be called after solve is called in a Python/C++...
const std::vector< int > & get_joint_map() const
const Eigen::VectorXd & get_joint_ref() const
void ComputeGoalLaplace(const Eigen::VectorXd &x, Eigen::VectorXd &goal)
static Eigen::VectorXd ComputeLaplace(Eigen::VectorXdRefConst eff_Phi, Eigen::MatrixXdRefConst weights, Eigen::MatrixXd *dist=nullptr, Eigen::VectorXd *wsum=nullptr)
Eigen::Vector3d GetEndPoint()
std::vector< CollisionProxy > get_collision_proxies()
void SetEndPoint(const Eigen::Vector3d &point)
Eigen::Vector3d GetLowerLimit(const int eff_id) const
void SetPreviousJointState(Eigen::VectorXdRefConst joint_state)
Logs previous joint state. SetPreviousJointState must be called after solve is called in a Python/C++...