Renamed LinearMotion -> CartesianMotion and LinearImpedanceMotion -> CartesianImpedanceMotion for consistency

Author: Tim Schneider

README.md

@@ -120,20 +120,20 @@ Robot robot("172.16.0.2");
 robot.setDynamicRel(0.05);
 
 // Move the end-effector 20cm in positive x-direction
-auto motion = LinearMotion(RobotPose(Affine({0.2, 0.0, 0.0}), 0.0), ReferenceType::Relative);
+auto motion = CartesianMotion(RobotPose(Affine({0.2, 0.0, 0.0}), 0.0), ReferenceType::Relative);
 
 // Finally move the robot
 robot.move(motion);
 ```
 
 The corresponding program in Python is
 ```python
-from franky import Affine, LinearMotion, Robot, ReferenceType
+from franky import Affine, CartesianMotion, Robot, ReferenceType
 
 robot = Robot("172.16.0.2")
 robot.relative_dynamics_factor = 0.05
 
-motion = LinearMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
+motion = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
 robot.move(motion)
 ```
 
@@ -213,7 +213,7 @@ In python, you can use them as follows:
 ```python
 import math
 from scipy.spatial.transform import Rotation
-from franky import JointWaypointMotion, JointWaypoint, JointPositionStopMotion, LinearMotion, CartesianWaypointMotion, CartesianWaypoint, Affine, RobotPose, ReferenceType, CartesianPoseStopMotion
+from franky import JointWaypointMotion, JointWaypoint, JointPositionStopMotion, CartesianMotion, CartesianWaypointMotion, CartesianWaypoint, Affine, RobotPose, ReferenceType, CartesianPoseStopMotion
 
 # A point-to-point motion in the joint space
 m1 = JointWaypointMotion([JointWaypoint([-1.8, 1.1, 1.7, -2.1, -1.1, 1.6, -0.4])])
@@ -230,15 +230,15 @@ m3 = JointPositionStopMotion()
 
 # A linear motion in cartesian space
 quat = Rotation.from_euler("xyz", [0, 0, math.pi / 2]).as_quat()
-m4 = LinearMotion(Affine([0.2, -0.4, 0.3], quat))
-m5 = LinearMotion(RobotPose(Affine([0.2, -0.4, 0.3], quat), elbow_position=1.7)) # With target elbow angle
+m4 = CartesianMotion(Affine([0.2, -0.4, 0.3], quat))
+m5 = CartesianMotion(RobotPose(Affine([0.2, -0.4, 0.3], quat), elbow_position=1.7)) # With target elbow angle
 
 # A linear motion in cartesian space relative to the initial position
 # (Note that this motion is relative both in position and orientation. Hence, when the robot's end-effector is oriented
 # differently, it will move in a different direction)
-m6 = LinearMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
+m6 = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
 
-# Generalization of LinearMotion that allows for multiple waypoints
+# Generalization of CartesianMotion that allows for multiple waypoints
 m7 = CartesianWaypointMotion([
   CartesianWaypoint(RobotPose(Affine([0.2, -0.4, 0.3], quat), elbow_position=1.7)),
   # The following waypoint is relative to the prior one and 50% slower
@@ -266,11 +266,11 @@ By adding reactions to the motion data, the robot can react to unforeseen events
 In the Python API, you can define conditions by using a comparison between a robot's value and a given threshold. 
 If the threshold is exceeded, the reaction fires. 
 ```python
-from franky import LinearMotion, Affine, ReferenceType, Measure, Reaction
+from franky import CartesianMotion, Affine, ReferenceType, Measure, Reaction
 
-motion = LinearMotion(Affine([0.0, 0.0, 0.1]), ReferenceType.Relative)  # Move down 10cm
+motion = CartesianMotion(Affine([0.0, 0.0, 0.1]), ReferenceType.Relative)  # Move down 10cm
 
-reaction_motion = LinearMotion(Affine([0.0, 0.0, 0.01]), ReferenceType.Relative)  # Move up for 1cm
+reaction_motion = CartesianMotion(Affine([0.0, 0.0, 0.01]), ReferenceType.Relative)  # Move up for 1cm
 
 # Trigger reaction if the Z force is greater than 30N
 reaction = Reaction(Measure.FORCE_Z > 30.0, reaction_motion)
@@ -322,7 +322,7 @@ Hence, callbacks might be executed significantly after their respective reaction
 
 In C++ you can additionally use lambdas to define more complex behaviours:
 ```c++
-auto motion = LinearMotion(RobotPose(Affine({0.0, 0.0, 0.2}), 0.0), ReferenceType::Relative);
+auto motion = CartesianMotion(RobotPose(Affine({0.0, 0.0, 0.2}), 0.0), ReferenceType::Relative);
 
 // Stop motion if force is over 10N
 auto stop_motion = StopMotion<franka::CartesianPose>()
@@ -357,16 +357,16 @@ By setting the `asynchronous` parameter of `Robot.move` to `True`, the function
 Instead, it returns immediately and, thus, allows the main thread to set new motions asynchronously. 
 ```python
 import time
-from franky import Affine, LinearMotion, Robot, ReferenceType
+from franky import Affine, CartesianMotion, Robot, ReferenceType
 
 robot = Robot("172.16.0.2")
 robot.relative_dynamics_factor = 0.05
 
-motion1 = LinearMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
+motion1 = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
 robot.move(motion1, asynchronous=True)
 
 time.sleep(0.5)
-motion2 = LinearMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
+motion2 = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
 robot.move(motion2, asynchronous=True)
 ```
 

examples/asynchronous.py

@@ -1,7 +1,7 @@
 from argparse import ArgumentParser
 import time
 
-from franky import Affine, LinearMotion, Robot, ReferenceType
+from franky import Affine, CartesianMotion, Robot, ReferenceType
 
 
 if __name__ == "__main__":
@@ -13,11 +13,11 @@
     robot = Robot(args.host)
     robot.relative_dynamics_factor = 0.05
 
-    motion1 = LinearMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
+    motion1 = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
     robot.move(motion1, asynchronous=True)
 
     time.sleep(0.5)
-    motion2 = LinearMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
+    motion2 = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
     robot.move(motion2, asynchronous=True)
 
     # Wait for the robot to finish its motion

examples/linear.cpp

@@ -21,11 +21,11 @@ int main(int argc, char *argv[]) {
 
   // Define and move forwards
   auto way = mk_affine(0.0, 0.05, 0.0);
-  auto motion_forward = std::make_shared<LinearMotion>(RobotPose(way), ReferenceType::Relative);
+  auto motion_forward = std::make_shared<CartesianMotion>(RobotPose(way), ReferenceType::Relative);
   robot.move(motion_forward);
 
   // And move backwards using the inverse motion
-  auto motion_backward = std::make_shared<LinearMotion>(RobotPose(way.inverse()), ReferenceType::Relative);
+  auto motion_backward = std::make_shared<CartesianMotion>(RobotPose(way.inverse()), ReferenceType::Relative);
   robot.move(motion_backward);
 
   return 0;

examples/linear.py

@@ -1,6 +1,6 @@
 from argparse import ArgumentParser
 
-from franky import Affine, LinearMotion, Robot, ReferenceType
+from franky import Affine, CartesianMotion, Robot, ReferenceType
 
 
 if __name__ == "__main__":
@@ -18,9 +18,9 @@
 
     # Define and move forwards
     target = Affine([0.0, 0.2, 0.0])
-    motion_forward = LinearMotion(target, ReferenceType.Relative)
+    motion_forward = CartesianMotion(target, ReferenceType.Relative)
     robot.move(motion_forward)
 
     # And move backwards using the inverse motion
-    motion_backward = LinearMotion(target.inverse)
+    motion_backward = CartesianMotion(target.inverse)
     robot.move(motion_backward)

examples/reaction.py

@@ -1,6 +1,6 @@
 from argparse import ArgumentParser
 
-from franky import Affine, JointMotion, Measure, Reaction, Robot, CartesianPoseStopMotion, LinearMotion, RobotPose, \
+from franky import Affine, JointMotion, Measure, Reaction, Robot, CartesianPoseStopMotion, CartesianMotion, RobotPose, \
     RobotState, ReferenceType
 
 
@@ -27,7 +27,7 @@ def reaction_callback(robot_state: RobotState, rel_time: float, abs_time: float)
     # Define and move forwards
     reaction = Reaction(Measure.ForceZ < -5.0, CartesianPoseStopMotion())
     reaction.register_callback(reaction_callback)
-    motion_down = LinearMotion(RobotPose(Affine([0.0, 0.0, -0.12]), -0.2), ReferenceType.Relative)
+    motion_down = CartesianMotion(RobotPose(Affine([0.0, 0.0, -0.12]), -0.2), ReferenceType.Relative)
     motion_down.add_reaction(reaction)
 
     # You can try to block the robot now.

franky/__init__.py

@@ -26,11 +26,12 @@
     CartesianPoseMotion,
     ImpedanceMotion,
     ExponentialImpedanceMotion,
-    LinearImpedanceMotion,
+    CartesianImpedanceMotion,
     JointWaypoint,
     JointWaypointMotion,
     JointMotion,
     CartesianWaypointMotion,
+    CartesianMotion,
     LinearMotion,
     CartesianPoseStopMotion,
     JointPositionStopMotion,

include/franky.hpp

@@ -6,8 +6,8 @@
 #include "franky/motion/impedance_motion.hpp"
 #include "franky/motion/joint_motion.hpp"
 #include "franky/motion/joint_waypoint_motion.hpp"
-#include "franky/motion/linear_impedance_motion.hpp"
-#include "franky/motion/linear_motion.hpp"
+#include "franky/motion/cartesian_impedance_motion.hpp"
+#include "franky/motion/cartesian_motion.hpp"
 #include "franky/motion/measure.hpp"
 #include "franky/motion/motion.hpp"
 #include "franky/motion/motion_generator.hpp"

include/franky/motion/linear_impedance_motion.hpp include/franky/motion/cartesian_impedance_motion.hpp

@@ -10,16 +10,16 @@
 
 namespace franky {
 
-class LinearImpedanceMotion : public ImpedanceMotion {
+class CartesianImpedanceMotion : public ImpedanceMotion {
  public:
   struct Params : public ImpedanceMotion::Params {
     bool return_when_finished{true};
     double finish_wait_factor{1.2}; // Wait a bit longer to stop
   };
 
-  explicit LinearImpedanceMotion(const Affine &target, double duration);
+  explicit CartesianImpedanceMotion(const Affine &target, double duration);
 
-  explicit LinearImpedanceMotion(const Affine &target, double duration, const Params &params);
+  explicit CartesianImpedanceMotion(const Affine &target, double duration, const Params &params);
 
  protected:
   void initImpl(const franka::RobotState &robot_state, const std::optional<franka::Torques> &previous_command) override;

include/franky/motion/linear_motion.hpp include/franky/motion/cartesian_motion.hpp

@@ -10,14 +10,17 @@
 
 namespace franky {
 
-class LinearMotion : public CartesianWaypointMotion {
+class CartesianMotion : public CartesianWaypointMotion {
  public:
-  explicit LinearMotion(
+  explicit CartesianMotion(
       const RobotPose &target,
       ReferenceType reference_type = ReferenceType::Absolute,
       const Affine &frame = Affine::Identity(),
       RelativeDynamicsFactor relative_dynamics_factor = 1.0,
       bool return_when_finished = true);
 };
 
+// Backwards compatibility
+using LinearMotion = CartesianMotion;
+
 }  // namespace franky

python/python.cpp

@@ -586,7 +586,7 @@ PYBIND11_MODULE(_franky, m) {
            "force_constraints"_a = std::nullopt,
            "exponential_decay"_a = 0.005);
 
-  py::class_<LinearImpedanceMotion, ImpedanceMotion, std::shared_ptr<LinearImpedanceMotion>>(m, "LinearImpedanceMotion")
+  py::class_<CartesianImpedanceMotion, ImpedanceMotion, std::shared_ptr<CartesianImpedanceMotion>>(m, "CartesianImpedanceMotion")
       .def(py::init<>([](
                const Affine &target,
                double duration,
@@ -604,9 +604,9 @@ PYBIND11_MODULE(_franky, m) {
                  force_constraints_active[i] = force_constraints.value()[i].has_value();
                }
              }
-             return std::make_shared<LinearImpedanceMotion>(
+             return std::make_shared<CartesianImpedanceMotion>(
                  target, duration,
-                 LinearImpedanceMotion::Params{
+                 CartesianImpedanceMotion::Params{
                      target_type, translational_stiffness, rotational_stiffness, force_constraints_value,
                      force_constraints_active, return_when_finished, finish_wait_factor});
            }),
@@ -698,14 +698,14 @@ PYBIND11_MODULE(_franky, m) {
            "relative_dynamics_factor"_a = 1.0,
            "return_when_finished"_a = true);
 
-  py::class_<LinearMotion, CartesianWaypointMotion, std::shared_ptr<LinearMotion>>(m, "LinearMotion")
+  py::class_<CartesianMotion, CartesianWaypointMotion, std::shared_ptr<CartesianMotion>>(m, "CartesianMotion")
       .def(py::init<>([](
                const RobotPose &target,
                ReferenceType reference_type,
                const std::optional<Affine> &frame,
                RelativeDynamicsFactor relative_dynamics_factor,
                bool return_when_finished) {
-             return std::make_shared<LinearMotion>(
+             return std::make_shared<CartesianMotion>(
                  target,
                  reference_type,
                  frame.value_or(Affine::Identity()),
@@ -718,6 +718,9 @@ PYBIND11_MODULE(_franky, m) {
            "relative_dynamics_factor"_a = 1.0,
            "return_when_finished"_a = true);
 
+  // Backwards compatibility
+  m.attr("LinearMotion") = m.attr("CartesianMotion");
+
   py::class_<StopMotion<franka::CartesianPose>,
              Motion<franka::CartesianPose>,
              std::shared_ptr<StopMotion<franka::CartesianPose>>>(m, "CartesianPoseStopMotion")

src/motion/linear_impedance_motion.cpp src/motion/cartesian_impedance_motion.cpp

@@ -1,4 +1,4 @@
-#include "franky/motion/linear_impedance_motion.hpp"
+#include "franky/motion/cartesian_impedance_motion.hpp"
 
 #include <map>
 
@@ -9,22 +9,22 @@
 
 namespace franky {
 
-LinearImpedanceMotion::LinearImpedanceMotion(const Affine &target, double duration)
-    : LinearImpedanceMotion(target, duration, Params()) {}
+CartesianImpedanceMotion::CartesianImpedanceMotion(const Affine &target, double duration)
+    : CartesianImpedanceMotion(target, duration, Params()) {}
 
-LinearImpedanceMotion::LinearImpedanceMotion(
-    const Affine &target, double duration, const LinearImpedanceMotion::Params &params)
+CartesianImpedanceMotion::CartesianImpedanceMotion(
+    const Affine &target, double duration, const CartesianImpedanceMotion::Params &params)
     : duration_(duration), params_(params), ImpedanceMotion(target, params) {}
 
-void LinearImpedanceMotion::initImpl(
+void CartesianImpedanceMotion::initImpl(
     const franka::RobotState &robot_state,
     const std::optional<franka::Torques> &previous_command) {
   ImpedanceMotion::initImpl(robot_state, previous_command);
   initial_pose_ = Affine(Eigen::Matrix4d::Map(robot_state.O_T_EE_c.data()));
 }
 
 std::tuple<Affine, bool>
-LinearImpedanceMotion::update(const franka::RobotState &robot_state, franka::Duration time_step, double time) {
+CartesianImpedanceMotion::update(const franka::RobotState &robot_state, franka::Duration time_step, double time) {
   double transition_parameter = time / duration_;
   Affine intermediate_goal;
   bool done;

src/motion/linear_motion.cpp src/motion/cartesian_motion.cpp

@@ -1,11 +1,11 @@
-#include "franky/motion/linear_motion.hpp"
+#include "franky/motion/cartesian_motion.hpp"
 
 #include "franky/robot_pose.hpp"
 #include "franky/motion/cartesian_waypoint_motion.hpp"
 
 namespace franky {
 
-LinearMotion::LinearMotion(
+CartesianMotion::CartesianMotion(
     const RobotPose &target,
     ReferenceType reference_type,
     const Affine& frame,