placo 0.5.6__tar.gz → 0.5.9__tar.gz

{placo-0.5.6 → placo-0.5.9}/CMakeLists.txt

@@ -102,7 +102,6 @@ add_library(libplaco SHARED
     src/placo/dynamics/dynamics_solver.cpp
     src/placo/dynamics/constraint.cpp
     src/placo/dynamics/avoid_self_collisions_constraint.cpp
-    src/placo/dynamics/reaction_ratio_constraint.cpp
 
     ${PROTO_SRCS}
     ${PROTO_HDRS}  

{placo-0.5.6 → placo-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: placo
-Version: 0.5.6
+Version: 0.5.9
 Summary: PlaCo: Rhoban Planning and Control
 Requires-Python: >= 3.8
 License-Expression: MIT

{placo-0.5.6 → placo-0.5.9}/bindings/expose-dynamics.cpp

@@ -15,6 +15,7 @@ using namespace placo::model;
 // Overloads
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(solve_overloads, solve, 0, 1);
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_torque_overloads, set_torque, 2, 4);
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_joint_overloads, set_joint, 2, 4);
 
 void exposeDynamics()
 {
@@ -50,7 +51,10 @@ void exposeDynamics()
       .def(
           "position_task", +[](PointContact& contact) -> PositionTask& { return *contact.position_task; },
           return_internal_reference<>())
-      .def_readwrite("unilateral", &PointContact::unilateral);
+      .def_readwrite("unilateral", &PointContact::unilateral)
+      .add_property(
+          "R_world_surface", +[](PointContact& contact) { return contact.R_world_surface; },
+          +[](PointContact& contact, Eigen::Matrix3d R) { contact.R_world_surface = R; });
 
   class__<Contact6D, bases<Contact>>("Contact6D", init<FrameTask&, bool>())
       .def(
@@ -64,10 +68,6 @@ void exposeDynamics()
       .def_readwrite("width", &Contact6D::width)
       .def("zmp", &Contact6D::zmp);
 
-  class__<RelativePointContact, bases<Contact>>("RelativePointContact", init<RelativePositionTask&>());
-
-  class__<Relative6DContact, bases<Contact>>("Relative6DContact", init<RelativeFrameTask&>());
-
   class__<ExternalWrenchContact, bases<Contact>>("ExternalWrenchContact", init<RobotWrapper::FrameIndex>())
       .add_property("frame_index", &ExternalWrenchContact::frame_index)
       .add_property(
@@ -81,24 +81,21 @@ void exposeDynamics()
       .add_property("problem", &DynamicsSolver::problem)
       .def_readwrite("damping", &DynamicsSolver::damping)
       .def_readwrite("dt", &DynamicsSolver::dt)
-      .def_readwrite("qdd_safe", &DynamicsSolver::qdd_safe)
+      .def("set_qdd_safe", &DynamicsSolver::set_qdd_safe)
+      .def("set_torque_limit", &DynamicsSolver::set_torque_limit)
       .def_readwrite("gravity_only", &DynamicsSolver::gravity_only)
       .def_readwrite("torque_cost", &DynamicsSolver::torque_cost)
       .def("mask_fbase", &DynamicsSolver::mask_fbase)
       .def("add_point_contact", &DynamicsSolver::add_point_contact, return_internal_reference<>())
       .def("add_unilateral_point_contact", &DynamicsSolver::add_unilateral_point_contact, return_internal_reference<>())
-      .def("add_relative_point_contact", &DynamicsSolver::add_relative_point_contact, return_internal_reference<>())
-      .def("add_relative_fixed_contact", &DynamicsSolver::add_relative_fixed_contact, return_internal_reference<>())
       .def("add_planar_contact", &DynamicsSolver::add_planar_contact, return_internal_reference<>())
       .def("add_fixed_contact", &DynamicsSolver::add_fixed_contact, return_internal_reference<>())
-      .def<ExternalWrenchContact& (DynamicsSolver::*)(std::string)>(
+      .def<ExternalWrenchContact& (DynamicsSolver::*)(std::string, std::string)>(
           "add_external_wrench_contact", &DynamicsSolver::add_external_wrench_contact, return_internal_reference<>())
       .def("add_puppet_contact", &DynamicsSolver::add_puppet_contact, return_internal_reference<>())
       .def("add_task_contact", &DynamicsSolver::add_task_contact, return_internal_reference<>())
       .def("add_avoid_self_collisions_constraint", &DynamicsSolver::add_avoid_self_collisions_constraint,
            return_internal_reference<>())
-      .def("add_reaction_ratio_constraint", &DynamicsSolver::add_reaction_ratio_constraint,
-           return_internal_reference<>())
       .def("enable_velocity_limits", &DynamicsSolver::enable_velocity_limits)
       .def("enable_velocity_vs_torque_limits", &DynamicsSolver::enable_velocity_vs_torque_limits)
       .def("enable_joint_limits", &DynamicsSolver::enable_joint_limits)
@@ -152,7 +149,6 @@ void exposeDynamics()
           "b", +[](const Task& task) { return task.b; })
       .add_property("kp", &Task::kp, &Task::kp)
       .add_property("kd", &Task::kd, &Task::kd)
-      .add_property("critically_damped", &Task::critically_damped, &Task::critically_damped)
       .add_property("error", &Task::error)
       .add_property("derror", &Task::derror);
 
@@ -162,6 +158,8 @@ void exposeDynamics()
           "target_world", +[](const PositionTask& task) { return task.target_world; }, &PositionTask::target_world)
       .add_property(
           "dtarget_world", +[](const PositionTask& task) { return task.dtarget_world; }, &PositionTask::dtarget_world)
+      .add_property(
+          "ddtarget_world", +[](const PositionTask& task) { return task.dtarget_world; }, &PositionTask::ddtarget_world)
       .add_property("mask", &PositionTask::mask, &PositionTask::mask);
 
   class__<CoMTask, bases<Task>>("DynamicsCoMTask", init<Eigen::Vector3d>())
@@ -229,7 +227,7 @@ void exposeDynamics()
       .add_property("T_a_b", &RelativeFrameTask::get_T_a_b, &RelativeFrameTask::set_T_a_b);
 
   class__<JointsTask, bases<Task>>("DynamicsJointsTask", init<>())
-      .def("set_joint", &JointsTask::set_joint)
+      .def("set_joint", &JointsTask::set_joint, set_joint_overloads())
       .def(
           "set_joints", +[](JointsTask& task,
                             boost::python::dict& py_dict) { update_map<std::string, double>(task.joints, py_dict); })
@@ -251,7 +249,4 @@ void exposeDynamics()
   class__<AvoidSelfCollisionsConstraint, bases<Constraint>>("AvoidSelfCollisionsDynamicsConstraint", init<>())
       .def_readwrite("self_collisions_margin", &AvoidSelfCollisionsConstraint::self_collisions_margin)
       .def_readwrite("self_collisions_trigger", &AvoidSelfCollisionsConstraint::self_collisions_trigger);
-
-  class__<ReactionRatioConstraint, bases<Constraint>>("DynamicsReactionRatioConstraint", init<Contact&, double>())
-      .def_readwrite("reaction_ratio", &ReactionRatioConstraint::reaction_ratio);
 }

{placo-0.5.6 → placo-0.5.9}/bindings/expose-kinematics.cpp

@@ -114,8 +114,7 @@ void exposeKinematics()
           .def<void (KinematicsSolver::*)(Task&)>("remove_task", &KinematicsSolver::remove_task)
           .def<void (KinematicsSolver::*)(FrameTask&)>("remove_task", &KinematicsSolver::remove_task)
           .def("remove_constraint", &KinematicsSolver::remove_constraint)
-          .def("solve", &KinematicsSolver::solve)
-          .def("add_q_noise", &KinematicsSolver::add_q_noise);
+          .def("solve", &KinematicsSolver::solve);
 
   class__<Task, bases<tools::Prioritized>, boost::noncopyable>("Task", no_init)
       .add_property(

{placo-0.5.6 → placo-0.5.9}/bindings/expose-robot-wrapper.cpp

@@ -125,7 +125,8 @@ void exposeRobotType(class_<RobotType, W1>& type)
           "joint_jacobian", +[](RobotType& robot, const std::string& joint,
                                 const std::string& reference) { return robot.joint_jacobian(joint, reference); })
       .def(
-          "make_solver", +[](RobotType& robot) { return placo::kinematics::KinematicsSolver(robot); });
+          "make_solver", +[](RobotType& robot) { return placo::kinematics::KinematicsSolver(robot); })
+      .def("add_q_noise", &RobotType::add_q_noise);
 }
 
 void exposeRobotWrapper()

{placo-0.5.6 → placo-0.5.9}/bindings/expose-tools.cpp

@@ -63,6 +63,7 @@ void exposeTools()
   class__<CubicSpline>("CubicSpline", init<optional<bool>>())
       .def("pos", &CubicSpline::pos)
       .def("vel", &CubicSpline::vel)
+      .def("acc", &CubicSpline::acc)
       .def("add_point", &CubicSpline::add_point)
       .def("clear", &CubicSpline::clear)
       .def("duration", &CubicSpline::duration);
@@ -70,6 +71,7 @@ void exposeTools()
   class__<CubicSpline3D>("CubicSpline3D")
       .def("pos", &CubicSpline3D::pos)
       .def("vel", &CubicSpline3D::vel)
+      .def("acc", &CubicSpline3D::acc)
       .def("add_point", &CubicSpline3D::add_point)
       .def("clear", &CubicSpline3D::clear)
       .def("duration", &CubicSpline3D::duration);