Autodiff
The manif package differentiates Jacobians with respect to a local perturbation on the tangent space. These Jacobians map tangent spaces, as described in this paper.
However, many non-linear solvers (e.g. Ceres) expect functions to be differentiated with respect to the underlying representation vector of the group element (e.g. with respect to quaternion vector for SO3
).
For this reason manif is compliant with the autodiff::dual
auto-differentiation type.
For reference of the size of the Jacobians returned when using autodiff::dual
, manif implements rotations in the following way:
- SO(2) and SE(2): as a complex number with
real = cos(theta)
andimag = sin(theta)
values. - SO(3), SE(3) and SE_2(3): as a unit quaternion, using the underlying
Eigen::Quaternion
type.
Therefore, the respective Jacobian sizes using autodiff::dual
are as follows:
- ℝ(n) : size n
- SO(2) : size 2
- SO(3) : size 4
- SE(2) : size 4
- SE(3) : size 7
- SE_2(3): size 10
Jacobians
Considering,
a group element (e.g. S3),
the vector tangent to the group at
,
an error function,
one is interested in expressing the Taylor series of the error function,
Therefore we have to compute the Jacobian
the Jacobian of
with respect to a perturbation on the tangent space, so that the state update happens on the manifold tangent space.
In some optimization frameworks, the computation of this Jacobian is decoupled in two folds as explained hereafter.
Using the autodiff library, a cost function can very easily designed as follows,
// functor to be evaluated auto fun = [](const auto& measurement, const auto& state_i, const auto& state_j){ return measurement - (state_j - state_i); };
where state_i
& state_j
belong to a group and measurement
belongs to the group's tangent.
Evaluating the function and its Jacobians is then,
using namespace autodiff; Eigen::MatrixXd J_e_xi = jacobian(fun, wrt(xi), at(meas_ij, xi, xj), e); Eigen::MatrixXd J_e_xj = jacobian(fun, wrt(xj), at(meas_ij, xi, xj), e);
It produces Jacobians of the form,
We thus then need to compute the Jacobian that will map to the tangent space - often called local-parameterization. A convenience function is provided in manif to do so as follow:
Eigen::MatrixXd J_xi_lp = autodiffLocalParameterizationJacobian<dual>(xi); Eigen::MatrixXd J_xj_lp = autodiffLocalParameterizationJacobian<dual>(xj);
This function computes the
operation's Jacobian evaluated for
thus providing the Jacobian,
Once both the cost function and local-parameterization's Jacobians are evaluated, they can be compose as,
Voila.
The intermediate Jacobians (2-3) that some solver requires are not available in manif
since the library provides directly the final Jacobian (1)
.
However, manif is compliant with autodiff::dual
auto-differentiation type to compute (2-3).