CalibratedCamera.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/geometry/BearingRange.h>
#include <gtsam/geometry/Point2.h>
#include <gtsam/geometry/Pose3.h>
#include <gtsam/base/concepts.h>
#include <gtsam/base/Manifold.h>
#include <gtsam/base/ThreadsafeException.h>
#include <gtsam/dllexport.h>
#include <boost/serialization/nvp.hpp>

namespace gtsam {

class GTSAM_EXPORT CheiralityException: public ThreadsafeException<
    CheiralityException> {
public:
  CheiralityException() :
      ThreadsafeException<CheiralityException>("Cheirality Exception") {
  }
};

class GTSAM_EXPORT PinholeBase {

public:

  typedef Rot3 Rotation;
  typedef Point3 Translation;

  typedef Point2 Measurement;

private:

  Pose3 pose_; 

protected:


  static Matrix26 Dpose(const Point2& pn, double d);

  static Matrix23 Dpoint(const Point2& pn, double d, const Matrix3& Rt);


public:


  static Pose3 LevelPose(const Pose2& pose2, double height);

  static Pose3 LookatPose(const Point3& eye, const Point3& target,
      const Point3& upVector);


  PinholeBase() {
  }

  explicit PinholeBase(const Pose3& pose) :
      pose_(pose) {
  }


  explicit PinholeBase(const Vector &v) :
      pose_(Pose3::Expmap(v)) {
  }


  bool equals(const PinholeBase &camera, double tol = 1e-9) const;

  void print(const std::string& s = "PinholeBase") const;


  const Pose3& pose() const {
    return pose_;
  }

  const Rot3& rotation() const {
    return pose_.rotation();
  }

  const Point3& translation() const {
    return pose_.translation();
  }

  const Pose3& getPose(OptionalJacobian<6, 6> H) const;


  static Point2 Project(const Point3& pc, //
      OptionalJacobian<2, 3> Dpoint = boost::none);

  static Point2 Project(const Unit3& pc, //
      OptionalJacobian<2, 2> Dpoint = boost::none);

  std::pair<Point2, bool> projectSafe(const Point3& pw) const;

  Point2 project2(const Point3& point, OptionalJacobian<2, 6> Dpose =
      boost::none, OptionalJacobian<2, 3> Dpoint = boost::none) const;

  Point2 project2(const Unit3& point,
      OptionalJacobian<2, 6> Dpose = boost::none,
      OptionalJacobian<2, 2> Dpoint = boost::none) const;

  static Point3 backproject_from_camera(const Point2& p, const double depth);


  inline static std::pair<size_t, size_t> translationInterval() {
    return std::make_pair(3, 5);
  }


private:

  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int /*version*/) {
    ar & BOOST_SERIALIZATION_NVP(pose_);
  }

};
// end of class PinholeBase

class GTSAM_EXPORT CalibratedCamera: public PinholeBase {

public:

  enum {
    dimension = 6
  };


  CalibratedCamera() {
  }

  explicit CalibratedCamera(const Pose3& pose) :
      PinholeBase(pose) {
  }


  // Create CalibratedCamera, with derivatives
  static CalibratedCamera Create(const Pose3& pose,
                                 OptionalJacobian<dimension, 6> H1 = boost::none) {
    if (H1)
      *H1 << I_6x6;
    return CalibratedCamera(pose);
  }

  static CalibratedCamera Level(const Pose2& pose2, double height);

  static CalibratedCamera Lookat(const Point3& eye, const Point3& target,
      const Point3& upVector);


  explicit CalibratedCamera(const Vector &v) :
      PinholeBase(v) {
  }


  virtual ~CalibratedCamera() {
  }


  CalibratedCamera retract(const Vector& d) const;

  Vector localCoordinates(const CalibratedCamera& T2) const;

  inline size_t dim() const {
    return 6;
  }

  inline static size_t Dim() {
    return 6;
  }


  Point2 project(const Point3& point, OptionalJacobian<2, 6> Dcamera =
      boost::none, OptionalJacobian<2, 3> Dpoint = boost::none) const;

  Point3 backproject(const Point2& pn, double depth) const {
    return pose().transform_from(backproject_from_camera(pn, depth));
  }

  double range(const Point3& point,
      OptionalJacobian<1, 6> Dcamera = boost::none,
      OptionalJacobian<1, 3> Dpoint = boost::none) const {
    return pose().range(point, Dcamera, Dpoint);
  }

  double range(const Pose3& pose, OptionalJacobian<1, 6> Dcamera = boost::none,
      OptionalJacobian<1, 6> Dpose = boost::none) const {
    return this->pose().range(pose, Dcamera, Dpose);
  }

  double range(const CalibratedCamera& camera, //
      OptionalJacobian<1, 6> H1 = boost::none, //
      OptionalJacobian<1, 6> H2 = boost::none) const {
    return pose().range(camera.pose(), H1, H2);
  }


private:


  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int /*version*/) {
    ar
        & boost::serialization::make_nvp("PinholeBase",
            boost::serialization::base_object<PinholeBase>(*this));
  }

};

// manifold traits
template <>
struct traits<CalibratedCamera> : public internal::Manifold<CalibratedCamera> {};

template <>
struct traits<const CalibratedCamera> : public internal::Manifold<CalibratedCamera> {};

// range traits, used in RangeFactor
template <typename T>
struct Range<CalibratedCamera, T> : HasRange<CalibratedCamera, T, double> {};

}  // namespace gtsam