Got rid of Vector type definition

Author: Tim Schneider

include/franky/path/time_parametrization.hpp

@@ -31,12 +31,12 @@ class TimeParametrization {
     // For blend segments: Constant path velocity ds
     // Check continuous, and go back to zero velocity otherwise
 
-    Vector<state_dimensions> max_velocity_v = Eigen::Map<const Vector<state_dimensions>>(
-        max_velocity.data(), max_velocity.size());
-    Vector<state_dimensions> max_accleration_v = Eigen::Map<const Vector<state_dimensions>>(
-        max_acceleration.data(), max_acceleration.size());
-    Vector<state_dimensions> max_jerk_v = Eigen::Map<const Vector<state_dimensions>>(
-        max_jerk.data(), max_jerk.size());
+    Eigen::Vector<double, state_dimensions> max_velocity_v = \
+        Eigen::Map<const Eigen::Vector<double, state_dimensions>>(max_velocity.data(), max_velocity.size());
+    Eigen::Vector<double, state_dimensions> max_accleration_v = \
+        Eigen::Map<const Eigen::Vector<double, state_dimensions>>(max_acceleration.data(), max_acceleration.size());
+    Eigen::Vector<double, state_dimensions> max_jerk_v = \
+        Eigen::Map<const Eigen::Vector<double, state_dimensions>>(max_jerk.data(), max_jerk.size());
 
     std::vector<std::tuple<double, double, double>> max_path_dynamics;
     for (auto segment : path.segments()) {

include/franky/robot.hpp

@@ -30,7 +30,7 @@ struct InvalidMotionTypeException : public std::runtime_error {
 class Robot : public franka::Robot {
  public:
   template<size_t dims>
-  using ScalarOrArray = std::variant<double, std::array<double, dims>, Vector<dims>>;
+  using ScalarOrArray = std::variant<double, std::array<double, dims>, Eigen::Vector<double, dims>>;
 
   struct Params {
     RelativeDynamicsFactor relative_dynamics_factor{1.0};
@@ -258,8 +258,8 @@ class Robot : public franka::Robot {
   std::array<double, dims> expand(const ScalarOrArray<dims> &input) {
     if (std::holds_alternative<std::array<double, dims>>(input)) {
       return std::get<std::array<double, dims>>(input);
-    } else if (std::holds_alternative<Vector<dims>>(input)) {
-      return toStd<dims>(std::get<Vector<dims>>(input));
+    } else if (std::holds_alternative<Eigen::Vector<double, dims>>(input)) {
+      return toStd<dims>(std::get<Eigen::Vector<double, dims>>(input));
     } else {
       std::array<double, dims> output;
       std::fill(output.begin(), output.end(), std::get<double>(input));

include/franky/types.hpp

@@ -5,11 +5,8 @@
 
 namespace franky {
 
-template<size_t dims>
-using Vector = Eigen::Matrix<double, dims, 1>;
-
-using Vector6d = Vector<6>;
-using Vector7d = Vector<7>;
+using Vector6d = Eigen::Vector<double, 6>;
+using Vector7d = Eigen::Vector<double, 7>;
 
 using Euler = Eigen::EulerAngles<double, Eigen::EulerSystemXYZ>;
 

python/python.cpp

@@ -33,7 +33,7 @@ using namespace franky;
 SequentialExecutor callback_executor;
 
 template<int dims>
-std::string vecToStr(const Vector<dims> &vec) {
+std::string vecToStr(const Eigen::Vector<double, dims> &vec) {
   std::stringstream ss;
   ss << "[";
   for (size_t i = 0; i < dims; i++) {
@@ -419,10 +419,10 @@ PYBIND11_MODULE(_franky, m) {
   py::class_<Affine>(m, "Affine")
       .def(py::init<const Eigen::Matrix<double, 4, 4> &>(),
            "transformation_matrix"_a = Eigen::Matrix<double, 4, 4>::Identity())
-      .def(py::init<>([](const Vector<3> &translation, const Vector<4> &quaternion) {
+      .def(py::init<>([](const Eigen::Vector3d &translation, const Eigen::Vector4d &quaternion) {
         return Affine().fromPositionOrientationScale(
-            translation, Eigen::Quaterniond(quaternion), Vector<3>::Ones());
-      }), "translation"_a = Vector<3>{0, 0, 0}, "quaternion"_a = Vector<4>{0, 0, 0, 1})
+            translation, Eigen::Quaterniond(quaternion), Eigen::Vector3d::Ones());
+      }), "translation"_a = Eigen::Vector3d{0, 0, 0}, "quaternion"_a = Eigen::Vector4d{0, 0, 0, 1})
       .def(py::init<const Affine &>()) // Copy constructor
       .def(py::self * py::self)
       .def_property_readonly("inverse", [](const Affine &affine) { return affine.inverse(); })
@@ -444,7 +444,8 @@ PYBIND11_MODULE(_franky, m) {
             if (t.size() != 2)
               throw std::runtime_error("Invalid state!");
             return Affine().fromPositionOrientationScale(
-                t[0].cast<Vector<3>>(), Eigen::Quaterniond(t[1].cast<Vector<4>>()), Vector<3>::Ones());
+                t[0].cast<Eigen::Vector3d>(),
+                    Eigen::Quaterniond(t[1].cast<Eigen::Vector4d>()), Eigen::Vector3d::Ones());
           }
       ));
 

src/motion/cartesian_waypoint_motion.cpp

@@ -22,10 +22,10 @@ void CartesianWaypointMotion::initWaypointMotion(
   RobotPose robot_pose(previous_command.value_or(franka::CartesianPose{robot_state.O_T_EE_c, robot_state.elbow_c}));
   ref_frame_ = Affine::Identity();
 
-  auto initial_velocity = Vector<6>::Map(robot_state.O_dP_EE_c.data());
+  auto initial_velocity = Vector6d::Map(robot_state.O_dP_EE_c.data());
   Vector7d initial_velocity_with_elbow = (Vector7d() << initial_velocity, robot_state.delbow_c[0]).finished();
 
-  auto initial_acceleration = Vector<6>::Map(robot_state.O_ddP_EE_c.data());
+  auto initial_acceleration = Vector6d::Map(robot_state.O_ddP_EE_c.data());
   Vector7d initial_acceleration_with_elbow = (Vector7d() << initial_acceleration, robot_state.ddelbow_c[0]).finished();
 
   target_robot_pose_ = robot_pose;
@@ -54,11 +54,11 @@ void CartesianWaypointMotion::setNewWaypoint(
   ref_frame_ = ref_frame_ * new_ref_to_old_ref;
   auto rot = new_ref_to_old_ref.inverse().rotation();
 
-  Vector<7> current_velocity = toEigen<7>(input_parameter.current_velocity);
+  Vector7d current_velocity = toEigen<7>(input_parameter.current_velocity);
   auto linear_vel_ref_frame = rot * current_velocity.head<3>();
   auto angular_vel_ref_frame = rot * current_velocity.segment<3>(3);
 
-  Vector<7> current_acc = toEigen<7>(input_parameter.current_acceleration);
+  Vector7d current_acc = toEigen<7>(input_parameter.current_acceleration);
   auto linear_acc_ref_frame = rot * current_acc.head<3>();
   auto angular_acc_ref_frame = rot * current_acc.segment<3>(3);