FrobeniusFactor.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 
 * GTSAM Copyright 2010-2019, Georgia Tech Research Corporation,
 * Atlanta, Georgia 30332-0415
 * All Rights Reserved
 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
 
 * See LICENSE for the license information
 
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <gtsam/geometry/Rot2.h>
#include <gtsam/geometry/Rot3.h>
#include <gtsam/geometry/SOn.h>
#include <gtsam/nonlinear/NonlinearFactor.h>
 
namespace gtsam {
 
GTSAM_EXPORT SharedNoiseModel
ConvertNoiseModel(const SharedNoiseModel &model, size_t n,
                  bool defaultToUnit = true);
 
template <class T>
class FrobeniusPrior : public NoiseModelFactorN<T> {
  inline constexpr static auto N = T::LieAlgebra::RowsAtCompileTime;
  inline constexpr static auto Dim = N * N;
  using MatrixNN = Eigen::Matrix<double, N, N>;
  Eigen::Matrix<double, Dim, 1> vecM_;  
 
 public:
 
  // Provide access to the Matrix& version of evaluateError:
  using NoiseModelFactor1<T>::evaluateError;
 
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  FrobeniusPrior(Key j, const MatrixNN& M,
                 const SharedNoiseModel& model = nullptr)
      : NoiseModelFactorN<T>(ConvertNoiseModel(model, Dim), j) {
    vecM_ << Eigen::Map<const Matrix>(M.data(), Dim, 1);
  }
 
  Vector evaluateError(const T& g, OptionalMatrixType H) const override {
    return g.vec(H) - vecM_;  // Jacobian is computed only when needed.
  }
};
 
template <class T>
class FrobeniusFactor : public NoiseModelFactorN<T, T> {
  inline constexpr static auto N = T::LieAlgebra::RowsAtCompileTime;
  inline constexpr static auto Dim = N * N;
 
 public:
 
  // Provide access to the Matrix& version of evaluateError:
  using NoiseModelFactor2<T, T>::evaluateError;
 
  FrobeniusFactor(Key j1, Key j2, const SharedNoiseModel& model = nullptr)
      : NoiseModelFactorN<T, T>(ConvertNoiseModel(model, Dim), j1, j2) {}
 
  Vector evaluateError(const T& T1, const T& T2,
                       OptionalMatrixType H1, OptionalMatrixType H2) const override {
    Vector error = T2.vec(H2) - T1.vec(H1);
    if (H1) *H1 = -*H1;
    return error;
  }
};
 
template <class T>
class FrobeniusBetweenFactor : public NoiseModelFactorN<T, T> {
  T T12_;  
  Eigen::Matrix<double, T::dimension, T::dimension>
      T2hat_H_T1_;  
  inline constexpr static auto N = T::LieAlgebra::RowsAtCompileTime;
  inline constexpr static auto Dim = N * N;
    
 public:
 
  // Provide access to the Matrix& version of evaluateError:
  using NoiseModelFactor2<T, T>::evaluateError;
 
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
 
  FrobeniusBetweenFactor(Key j1, Key j2, const T& T12,
                         const SharedNoiseModel& model = nullptr)
      : NoiseModelFactorN<T, T>(ConvertNoiseModel(model, Dim), j1, j2),
        T12_(T12),
        T2hat_H_T1_(T12.inverse().AdjointMap()) {}
 
 
  void
  print(const std::string &s,
        const KeyFormatter &keyFormatter = DefaultKeyFormatter) const override {
    std::cout << s << "FrobeniusBetweenFactor<" << demangle(typeid(T).name())
              << ">(" << keyFormatter(this->key1()) << ","
              << keyFormatter(this->key2()) << ")\n";
    traits<T>::Print(T12_, "  T12: ");
    this->noiseModel_->print("  noise model: ");
  }
 
  bool equals(const NonlinearFactor &expected,
              double tol = 1e-9) const override {
    auto e = dynamic_cast<const FrobeniusBetweenFactor *>(&expected);
    return e != nullptr && NoiseModelFactorN<T, T>::equals(*e, tol) &&
           traits<T>::Equals(this->T12_, e->T12_, tol);
  }
 
 
  Vector evaluateError(const T& T1, const T& T2,
                       OptionalMatrixType H1, OptionalMatrixType H2) const override {
    const T T2hat = T1.compose(T12_);
    Eigen::Matrix<double, Dim, T::dimension> vec_H_T2hat;
    Vector error = T2.vec(H2) - T2hat.vec(H1 ? &vec_H_T2hat : nullptr);
    if (H1) *H1 = -vec_H_T2hat * T2hat_H_T1_;
    return error;
  }
};
 
}  // namespace gtsam