Bindings to EvalMotionDerivatives method.

Signed-off-by: Franco Cipollone <[email protected]>

maliput-sys/src/api/api.h

@@ -151,6 +151,10 @@ std::unique_ptr<LaneEnd> Lane_GetDefaultBranch(const Lane& lane, bool start) {
   return default_branch ? std::make_unique<LaneEnd>(*default_branch) : nullptr;
 }
 
+std::unique_ptr<LanePosition> Lane_EvalMotionDerivatives(const Lane& lane, const LanePosition& lane_position, rust::f64 sigma_v, rust::f64 rho_v, rust::f64 eta_v) {
+  return std::make_unique<LanePosition>(lane.EvalMotionDerivatives(lane_position, IsoLaneVelocity{sigma_v, rho_v, eta_v}));
+}
+
 std::unique_ptr<RoadPosition> RoadPosition_new(const Lane* lane, const LanePosition& pos) {
   return std::make_unique<RoadPosition>(lane, pos);
 }

maliput-sys/src/api/mod.rs

@@ -122,6 +122,13 @@ pub mod ffi {
         fn Lane_GetConfluentBranches(lane: &Lane, start: bool) -> *const LaneEndSet;
         fn Lane_GetOngoingBranches(lane: &Lane, start: bool) -> *const LaneEndSet;
         fn Lane_GetDefaultBranch(lane: &Lane, start: bool) -> UniquePtr<LaneEnd>;
+        fn Lane_EvalMotionDerivatives(
+            lane: &Lane,
+            lane_position: &LanePosition,
+            sigma_v: f64,
+            rho_v: f64,
+            eta_v: f64,
+        ) -> UniquePtr<LanePosition>;
 
         // Segment bindings definitions
         type Segment;

maliput/src/api/mod.rs

@@ -510,6 +510,28 @@ impl HBounds {
     }
 }
 
+/// Isometric velocity vector in a `Lane`-frame.
+///
+/// sigma_v, rho_v, and eta_v are the components of velocity in a
+/// (sigma, rho, eta) coordinate system.  (sigma, rho, eta) have the same
+/// orientation as the (s, r, h) at any given point in space, however they
+/// form an isometric system with a Cartesian distance metric.  Hence,
+/// IsoLaneVelocity represents a "real" physical velocity vector (albeit
+/// with an orientation relative to the road surface).
+#[derive(Default, Copy, Clone, Debug, PartialEq)]
+pub struct IsoLaneVelocity {
+    pub sigma_v: f64,
+    pub rho_v: f64,
+    pub eta_v: f64,
+}
+
+impl IsoLaneVelocity {
+    /// Create a new `IsoLaneVelocity` with the given `sigma_v`, `rho_v`, and `eta_v` components.
+    pub fn new(sigma_v: f64, rho_v: f64, eta_v: f64) -> IsoLaneVelocity {
+        IsoLaneVelocity { sigma_v, rho_v, eta_v }
+    }
+}
+
 /// A maliput::api::Lane
 /// Wrapper around C++ implementation `maliput::api::Lane`.
 pub struct Lane<'a> {
@@ -628,6 +650,22 @@ impl<'a> Lane<'a> {
         let bounds = maliput_sys::api::ffi::Lane_elevation_bounds(self.lane, s, r);
         HBounds::new(bounds.min(), bounds.max())
     }
+    /// Computes derivatives of [LanePosition] given a velocity vector `velocity`.
+    /// `velocity` is a isometric velocity vector oriented in the `Lane`-frame
+    /// at `position`.
+    ///
+    /// Returns `Lane`-frame derivatives packed into a [LanePosition] struct.
+    pub fn eval_motion_derivatives(&self, lane_position: &LanePosition, velocity: &IsoLaneVelocity) -> LanePosition {
+        LanePosition {
+            lp: maliput_sys::api::ffi::Lane_EvalMotionDerivatives(
+                self.lane,
+                lane_position.lp.as_ref().expect(""),
+                velocity.sigma_v,
+                velocity.rho_v,
+                velocity.eta_v,
+            ),
+        }
+    }
     /// Returns the lane's BranchPoint for the specified end.
     pub fn get_branch_point(&self, end: &LaneEnd) -> BranchPoint {
         assert! {

maliput/tests/lane_test.rs

@@ -90,6 +90,11 @@ fn lane_api() {
         default_branch.is_none(),
         branch_point.get_default_branch(&lane_end).is_none()
     );
+
+    let velocity = maliput::api::IsoLaneVelocity::new(1., 0., 0.);
+    let expected_derivatives = maliput::api::LanePosition::new(1., 0., 0.);
+    let lane_frame_derivatives = lane.eval_motion_derivatives(&maliput::api::LanePosition::new(0., 0., 0.), &velocity);
+    assert_eq!(expected_derivatives, lane_frame_derivatives);
 }
 
 #[test]