ProjectionFactor.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/linear/FixedJacobianFactor.h>
#include <gtsam/nonlinear/NonlinearFactor.h>
#include <gtsam/nonlinear/NoiseModelFactorN.h>
#include <gtsam/geometry/PinholeCamera.h>
#include <gtsam/geometry/Pose3.h>
#include <gtsam/geometry/Point3.h>
#include <gtsam/geometry/Cal3_S2.h>
#include <optional>
 
namespace gtsam {

  template <class POSE = Pose3, class LANDMARK = Point3,
            class CALIBRATION = Cal3_S2>
  class GenericProjectionFactor
      : public NoiseModelFactorT<Vector2, POSE, LANDMARK> {
  protected:
 
    // Keep a copy of measurement and calibration for I/O
    Point2 measured_;                    
    std::shared_ptr<CALIBRATION> K_;  
    std::optional<POSE> body_P_sensor_; 
 
    // verbosity handling for Cheirality Exceptions
    bool throwCheirality_; 
    bool verboseCheirality_; 
 
  public:

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

    typedef GenericProjectionFactor<POSE, LANDMARK, CALIBRATION> This;

    typedef std::shared_ptr<This> shared_ptr;

    GenericProjectionFactor() :
        measured_(0, 0), throwCheirality_(false), verboseCheirality_(false) {
    }

    GenericProjectionFactor(const Point2& measured, const SharedNoiseModel& model,
        Key poseKey, Key pointKey, const std::shared_ptr<CALIBRATION>& K,
        std::optional<POSE> body_P_sensor = {}) :
          Base(model, poseKey, pointKey), measured_(measured), K_(K), body_P_sensor_(body_P_sensor),
          throwCheirality_(false), verboseCheirality_(false) {}

    GenericProjectionFactor(const Point2& measured, const SharedNoiseModel& model,
        Key poseKey, Key pointKey, const std::shared_ptr<CALIBRATION>& K,
        bool throwCheirality, bool verboseCheirality,
        std::optional<POSE> body_P_sensor = {}) :
          Base(model, poseKey, pointKey), measured_(measured), K_(K), body_P_sensor_(body_P_sensor),
          throwCheirality_(throwCheirality), verboseCheirality_(verboseCheirality) {}

    ~GenericProjectionFactor() override {}

    gtsam::NonlinearFactor::shared_ptr clone() const override {
      return std::static_pointer_cast<gtsam::NonlinearFactor>(
          gtsam::NonlinearFactor::shared_ptr(new This(*this))); }

    void print(const std::string& s = "", const KeyFormatter& keyFormatter = DefaultKeyFormatter) const override {
      std::cout << s << "GenericProjectionFactor, z = ";
      traits<Point2>::Print(measured_);
      if(this->body_P_sensor_)
        this->body_P_sensor_->print("  sensor pose in body frame: ");
      Base::print("", keyFormatter);
    }

    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)
          && ((!body_P_sensor_ && !e->body_P_sensor_) || (body_P_sensor_ && e->body_P_sensor_ && body_P_sensor_->equals(*e->body_P_sensor_)));
    }

    Vector2 evaluateError(const Pose3& pose, const Point3& point,
                          OptionalMatrixType H1,
                          OptionalMatrixType H2) const override {
      try {
        if(body_P_sensor_) {
          if(H1) {
            gtsam::Matrix H0;
            PinholeCamera<CALIBRATION> camera(pose.compose(*body_P_sensor_, H0), *K_);
            Point2 reprojectionError(camera.project(point, H1, H2, {}) - measured_);
            *H1 = *H1 * H0;
            return reprojectionError;
          } else {
            PinholeCamera<CALIBRATION> camera(pose.compose(*body_P_sensor_), *K_);
            return camera.project(point, H1, H2, {}) - measured_;
          }
        } else {
          PinholeCamera<CALIBRATION> camera(pose, *K_);
          return camera.project(point, H1, H2, {}) - measured_;
        }
      } catch( CheiralityException& e) {
        if (H1) *H1 = Matrix::Zero(2,6);
        if (H2) *H2 = Matrix::Zero(2,3);
        if (verboseCheirality_)
          std::cout << e.what() << ": Landmark "<< DefaultKeyFormatter(this->key2()) <<
              " moved behind camera " << DefaultKeyFormatter(this->key1()) << std::endl;
        if (throwCheirality_)
          throw CheiralityException(this->key2());
      }
      return Vector2::Constant(2.0 * K_->fx());
    }

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

    const std::shared_ptr<CALIBRATION> calibration() const {
      return K_;
    }

    const std::optional<POSE>& body_P_sensor() const {
      return body_P_sensor_;
    }

    inline bool verboseCheirality() const { return verboseCheirality_; }

    inline bool throwCheirality() const { return throwCheirality_; }
 
  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_);
      ar & BOOST_SERIALIZATION_NVP(body_P_sensor_);
      ar & BOOST_SERIALIZATION_NVP(throwCheirality_);
      ar & BOOST_SERIALIZATION_NVP(verboseCheirality_);
    }
#endif
};

  template<class POSE, class LANDMARK, class CALIBRATION>
  struct traits<GenericProjectionFactor<POSE, LANDMARK, CALIBRATION> > :
      public Testable<GenericProjectionFactor<POSE, LANDMARK, CALIBRATION> > {
  };
 
} // \ namespace gtsam