InvDepthFactorVariant3.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 
 * GTSAM Copyright 2010, 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/nonlinear/NonlinearFactor.h>
#include <gtsam/nonlinear/NoiseModelFactorN.h>
#include <gtsam/geometry/PinholeCamera.h>
#include <gtsam/geometry/Cal3_S2.h>
#include <gtsam/geometry/Pose3.h>
#include <gtsam/geometry/Point2.h>
#include <gtsam/base/numericalDerivative.h>
 
namespace gtsam {

class InvDepthFactorVariant3a
    : public NoiseModelFactorT<Vector2, Pose3, Vector3> {
protected:
 
  // Keep a copy of measurement and calibration for I/O
  Point2 measured_;        
  Cal3_S2::shared_ptr K_;  
 
public:

  typedef NoiseModelFactorT<Vector2, Pose3, Vector3> Base;
 
  // Provide access to the Matrix& version of evaluateError:
  using Base::evaluateError;

  typedef InvDepthFactorVariant3a This;

  typedef std::shared_ptr<This> shared_ptr;

  InvDepthFactorVariant3a() :
      measured_(0.0, 0.0), K_(new Cal3_S2(444, 555, 666, 777, 888)) {
  }

  InvDepthFactorVariant3a(const Key poseKey, const Key landmarkKey,
      const Point2& measured, const Cal3_S2::shared_ptr& K, const SharedNoiseModel& model) :
        Base(model, poseKey, landmarkKey), measured_(measured), K_(K) {}

  ~InvDepthFactorVariant3a() override {}

  void print(const std::string& s = "InvDepthFactorVariant3a",
      const KeyFormatter& keyFormatter = DefaultKeyFormatter) const override {
    Base::print(s, keyFormatter);
    traits<Point2>::Print(measured_, s + ".z");
  }

  bool equals(const NonlinearFactor& p, double tol = 1e-9) const override {
    const This *e = dynamic_cast<const This*>(&p);
    return e
        && Base::equals(p, tol)
        && traits<Point2>::Equals(this->measured_, e->measured_, tol)
        && this->K_->equals(*e->K_, tol);
  }
 
  Vector inverseDepthError(const Pose3& pose, const Vector3& landmark) const {
    try {
      // Calculate the 3D coordinates of the landmark in the Pose frame
      double theta = landmark(0), phi = landmark(1), rho = landmark(2);
      Point3 pose_P_landmark(cos(phi)*sin(theta)/rho, sin(phi)/rho, cos(phi)*cos(theta)/rho);
      // Convert the landmark to world coordinates
      Point3 world_P_landmark = pose.transformFrom(pose_P_landmark);
      // Project landmark into Pose2
      PinholeCamera<Cal3_S2> camera(pose, *K_);
      return camera.project(world_P_landmark) - measured_;
    } catch( CheiralityException& e) {
      std::cout << e.what()
          << ": Inverse Depth Landmark [" << DefaultKeyFormatter(this->key<1>()) << "," << DefaultKeyFormatter(this->key<2>()) << "]"
          << " moved behind camera [" << DefaultKeyFormatter(this->key<1>()) << "]"
          << std::endl;
      return Vector::Ones(2) * 2.0 * K_->fx();
    }
    return Vector{{0.0}};
  }

  Vector2 evaluateError(const Pose3& pose, const Vector3& landmark,
                        OptionalMatrixType H1,
                        OptionalMatrixType H2) const override {
 
    if(H1) {
      (*H1) = numericalDerivative11<Vector, Pose3>(
          std::bind(&InvDepthFactorVariant3a::inverseDepthError, this,
                      std::placeholders::_1, landmark),
          pose);
    }
    if(H2) {
      (*H2) = numericalDerivative11<Vector, Vector3>(
          std::bind(&InvDepthFactorVariant3a::inverseDepthError, this, pose,
                      std::placeholders::_1),
          landmark);
    }
 
    return inverseDepthError(pose, landmark);
  }

  const Point2& imagePoint() const {
    return measured_;
  }

  const Cal3_S2::shared_ptr calibration() const {
    return K_;
  }
 
private:
 
#if GTSAM_ENABLE_BOOST_SERIALIZATION  
  friend class boost::serialization::access;
  template<class ARCHIVE>
  void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
    ar & BOOST_SERIALIZATION_NVP(measured_);
    ar & BOOST_SERIALIZATION_NVP(K_);
  }
#endif
};

class InvDepthFactorVariant3b
    : public NoiseModelFactorT<Vector2, Pose3, Pose3, Vector3> {
protected:
 
  // Keep a copy of measurement and calibration for I/O
  Point2 measured_;        
  Cal3_S2::shared_ptr K_;  
 
public:

  typedef NoiseModelFactorT<Vector2, Pose3, Pose3, Vector3> Base;

  typedef InvDepthFactorVariant3b This;

  typedef std::shared_ptr<This> shared_ptr;

  InvDepthFactorVariant3b() :
      measured_(0.0, 0.0), K_(new Cal3_S2(444, 555, 666, 777, 888)) {
  }

  InvDepthFactorVariant3b(const Key poseKey1, const Key poseKey2, const Key landmarkKey,
      const Point2& measured, const Cal3_S2::shared_ptr& K, const SharedNoiseModel& model) :
        Base(model, poseKey1, poseKey2, landmarkKey), measured_(measured), K_(K) {}

  ~InvDepthFactorVariant3b() override {}

  void print(const std::string& s = "InvDepthFactorVariant3",
      const KeyFormatter& keyFormatter = DefaultKeyFormatter) const override {
    Base::print(s, keyFormatter);
    traits<Point2>::Print(measured_, s + ".z");
  }

  bool equals(const NonlinearFactor& p, double tol = 1e-9) const override {
    const This *e = dynamic_cast<const This*>(&p);
    return e
        && Base::equals(p, tol)
        && traits<Point2>::Equals(this->measured_, e->measured_, tol)
        && this->K_->equals(*e->K_, tol);
  }
 
  Vector inverseDepthError(const Pose3& pose1, const Pose3& pose2, const Vector3& landmark) const {
    try {
      // Calculate the 3D coordinates of the landmark in the Pose1 frame
      double theta = landmark(0), phi = landmark(1), rho = landmark(2);
      Point3 pose1_P_landmark(cos(phi)*sin(theta)/rho, sin(phi)/rho, cos(phi)*cos(theta)/rho);
      // Convert the landmark to world coordinates
      Point3 world_P_landmark = pose1.transformFrom(pose1_P_landmark);
      // Project landmark into Pose2
      PinholeCamera<Cal3_S2> camera(pose2, *K_);
      return camera.project(world_P_landmark) - measured_;
    } catch( CheiralityException& e) {
      std::cout << e.what()
          << ": Inverse Depth Landmark [" << DefaultKeyFormatter(this->key<1>()) << "," << DefaultKeyFormatter(this->key<3>()) << "]"
          << " moved behind camera " << DefaultKeyFormatter(this->key<2>())
          << std::endl;
      return Vector::Ones(2) * 2.0 * K_->fx();
    }
    return Vector{{0.0}};
  }

  Vector2 evaluateError(const Pose3& pose1, const Pose3& pose2,
                        const Vector3& landmark, OptionalMatrixType H1,
                        OptionalMatrixType H2,
                        OptionalMatrixType H3) const override {
 
    if(H1)
      (*H1) = numericalDerivative11<Vector, Pose3>(
          std::bind(&InvDepthFactorVariant3b::inverseDepthError, this,
                      std::placeholders::_1, pose2, landmark),
          pose1);
 
    if(H2)
      (*H2) = numericalDerivative11<Vector, Pose3>(
          std::bind(&InvDepthFactorVariant3b::inverseDepthError, this, pose1,
                      std::placeholders::_1, landmark),
          pose2);
 
    if(H3)
      (*H3) = numericalDerivative11<Vector, Vector3>(
          std::bind(&InvDepthFactorVariant3b::inverseDepthError, this, pose1,
                      pose2, std::placeholders::_1),
          landmark);
 
    return inverseDepthError(pose1, pose2, landmark);
  }

  const Point2& imagePoint() const {
    return measured_;
  }

  const Cal3_S2::shared_ptr calibration() const {
    return K_;
  }
 
private:
 
#if GTSAM_ENABLE_BOOST_SERIALIZATION
  friend class boost::serialization::access;
  template<class ARCHIVE>
  void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
    ar & BOOST_SERIALIZATION_NVP(measured_);
    ar & BOOST_SERIALIZATION_NVP(K_);
  }
#endif
};
 
} // \ namespace gtsam