doxygen/a01256_source.html

/* ----------------------------------------------------------------------------


 * 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/base/std_optional_serialization.h>

#include <gtsam/geometry/Point3.h>

#include <gtsam/geometry/Pose3.h>

#include <gtsam/navigation/GnssCommon.h>

#include <gtsam/nonlinear/NoiseModelFactorN.h>

#include <gtsam/nonlinear/NonlinearFactor.h>


#include <optional>

#include <string>


namespace gtsam {


using PseudorangeBase = GnssMeasurementBase;


class GTSAM_EXPORT PseudorangeFactor

    : public NoiseModelFactorT<Vector1, Point3, double>,

                                       private PseudorangeBase {

 private:

  typedef NoiseModelFactorT<Vector1, Point3, double> Base;


 public:

  // Provide access to the Matrix& version of evaluateError:

  using Base::evaluateError;


  typedef std::shared_ptr<PseudorangeFactor> shared_ptr;


  typedef PseudorangeFactor This;


  PseudorangeFactor() = default;


  virtual ~PseudorangeFactor() = default;


  PseudorangeFactor(

      Key receiverPositionKey, Key receiverClockBiasKey,

      double measuredPseudorange, const Point3& satellitePosition,

      double satelliteClockBias = 0.0,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  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;


  bool equals(const NonlinearFactor& expected,

              double tol = 1e-9) const override;


  Vector1 evaluateError(const Point3& receiverPosition,

                        const double& receiverClockBias,

                        OptionalMatrixType HreceiverPos,

                        OptionalMatrixType HreceiverClockBias) const override;


 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(measurement_);

    ar& BOOST_SERIALIZATION_NVP(satPos_);

    ar& BOOST_SERIALIZATION_NVP(satClkBias_);

  }

#endif

};


template <>

struct traits<PseudorangeFactor> : public Testable<PseudorangeFactor> {};


class GTSAM_EXPORT UndifferencedPseudorangeFactor

    : public NoiseModelFactorN<Point3, double, double, double>,

      private PseudorangeBase {

 private:

  typedef NoiseModelFactorN<Point3, double, double, double> Base;

  double tropoMap_ = 0.0;

  double ionoCoeff_ = 1.0;


 public:

  using Base::evaluateError;

  typedef std::shared_ptr<UndifferencedPseudorangeFactor> shared_ptr;

  typedef UndifferencedPseudorangeFactor This;


  UndifferencedPseudorangeFactor() = default;

  virtual ~UndifferencedPseudorangeFactor() = default;


  UndifferencedPseudorangeFactor(

      Key receiverPositionKey, Key receiverClockBiasKey,

      Key tropoZenithWetKey, Key slantIonoKey,

      double measuredPseudorange, const Point3& satellitePosition,

      double tropoWetMapping, double ionoCoefficient,

      double satelliteClockBias = 0.0,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  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;

  bool equals(const NonlinearFactor& expected,

              double tol = 1e-9) const override;


  Vector evaluateError(const Point3& receiverPosition,

                       const double& receiverClockBias,

                       const double& tropoZenithWet,

                       const double& slantIono,

                       OptionalMatrixType HreceiverPos,

                       OptionalMatrixType HreceiverClockBias,

                       OptionalMatrixType HtropoZenithWet,

                       OptionalMatrixType HslantIono) const override;


  inline double tropoMapping() const { return tropoMap_; }

  inline double ionoCoefficient() const { return ionoCoeff_; }


 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(measurement_);

    ar& BOOST_SERIALIZATION_NVP(satPos_);

    ar& BOOST_SERIALIZATION_NVP(satClkBias_);

    ar& BOOST_SERIALIZATION_NVP(tropoMap_);

    ar& BOOST_SERIALIZATION_NVP(ionoCoeff_);

  }

#endif

};


template <>


struct traits<UndifferencedPseudorangeFactor>

    : public Testable<UndifferencedPseudorangeFactor> {};


class GTSAM_EXPORT UndifferencedPseudorangeFactorArm

    : public NoiseModelFactorN<Pose3, double, double, double>,

      private PseudorangeBase {

 private:

  typedef NoiseModelFactorN<Pose3, double, double, double> Base;

  gnss::LeverArm arm_;

  double tropoMap_ = 0.0;

  double ionoCoeff_ = 1.0;


 public:

  using Base::evaluateError;

  typedef std::shared_ptr<UndifferencedPseudorangeFactorArm> shared_ptr;

  typedef UndifferencedPseudorangeFactorArm This;


  UndifferencedPseudorangeFactorArm()

      : PseudorangeBase{0.0, Point3(0, 0, 0), 0.0} {}

  virtual ~UndifferencedPseudorangeFactorArm() = default;


  UndifferencedPseudorangeFactorArm(

      Key poseKey, Key receiverClockBiasKey, Key tropoZenithWetKey,

      Key slantIonoKey, double measuredPseudorange,

      const Point3& satellitePosition, const Point3& leverArm,

      double tropoWetMapping, double ionoCoefficient,

      double satelliteClockBias = 0.0,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  UndifferencedPseudorangeFactorArm(

      Key poseKey, Key receiverClockBiasKey, Key tropoZenithWetKey,

      Key slantIonoKey, double measuredPseudorange,

      const Point3& satellitePosition, const Point3& leverArm,

      const Pose3& ecef_T_nav, double tropoWetMapping, double ionoCoefficient,

      double satelliteClockBias = 0.0,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  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;

  bool equals(const NonlinearFactor& expected,

              double tol = 1e-9) const override;


  Vector evaluateError(const Pose3& pose, const double& receiverClockBias,

                       const double& tropoZenithWet, const double& slantIono,

                       OptionalMatrixType H_pose,

                       OptionalMatrixType HreceiverClockBias,

                       OptionalMatrixType HtropoZenithWet,

                       OptionalMatrixType HslantIono) const override;


  inline const Point3& leverArm() const { return arm_.b; }

  inline const std::optional<Pose3>& ecefTnav() const { return arm_.ecef_T_nav; }

  inline double tropoMapping() const { return tropoMap_; }

  inline double ionoCoefficient() const { return ionoCoeff_; }


 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(measurement_);

    ar& BOOST_SERIALIZATION_NVP(satPos_);

    ar& BOOST_SERIALIZATION_NVP(satClkBias_);

    ar& boost::serialization::make_nvp("bL_", arm_.b);

    ar& boost::serialization::make_nvp("ecef_T_nav_", arm_.ecef_T_nav);

    ar& BOOST_SERIALIZATION_NVP(tropoMap_);

    ar& BOOST_SERIALIZATION_NVP(ionoCoeff_);

  }

#endif

};


template <>


struct traits<UndifferencedPseudorangeFactorArm>

    : public Testable<UndifferencedPseudorangeFactorArm> {};


class GTSAM_EXPORT DifferentialPseudorangeFactor

    : public NoiseModelFactorT<Vector1, Point3, double, double>,

      private PseudorangeBase {

 private:

  typedef NoiseModelFactorT<Vector1, Point3, double, double> Base;


 public:

  using Base::evaluateError;

  typedef std::shared_ptr<DifferentialPseudorangeFactor> shared_ptr;

  typedef DifferentialPseudorangeFactor This;


  DifferentialPseudorangeFactor() = default;

  virtual ~DifferentialPseudorangeFactor() = default;


  DifferentialPseudorangeFactor(

      Key receiverPositionKey, Key receiverClockBiasKey,

      Key differentialCorrectionKey, double measuredPseudorange,

      const Point3& satellitePosition, double satelliteClockBias = 0.0,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  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;

  bool equals(const NonlinearFactor& expected,

              double tol = 1e-9) const override;

  Vector1 evaluateError(

      const Point3& receiverPosition, const double& receiverClock_bias,

      const double& differentialCorrection, OptionalMatrixType HreceiverPos,

      OptionalMatrixType HreceiverClockBias,

      OptionalMatrixType HdifferentialCorrection) const override;


 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(measurement_);

    ar& BOOST_SERIALIZATION_NVP(satPos_);

    ar& BOOST_SERIALIZATION_NVP(satClkBias_);

  }

#endif

};


template <>


struct traits<DifferentialPseudorangeFactor>

    : public Testable<DifferentialPseudorangeFactor> {};


class GTSAM_EXPORT PseudorangeFactorArm

    : public NoiseModelFactorT<Vector1, Pose3, double>,

      private PseudorangeBase {

 private:

  typedef NoiseModelFactorT<Vector1, Pose3, double> Base;


  gnss::LeverArm arm_;


 public:

  // Provide access to the Matrix& version of evaluateError:

  using Base::evaluateError;


  typedef std::shared_ptr<PseudorangeFactorArm> shared_ptr;


  typedef PseudorangeFactorArm This;


  PseudorangeFactorArm() : PseudorangeBase{0.0, Point3(0, 0, 0), 0.0} {}


  virtual ~PseudorangeFactorArm() = default;


  PseudorangeFactorArm(

      Key poseKey, Key receiverClockBiasKey,

      double measuredPseudorange, const Point3& satellitePosition,

      const Point3& leverArm, double satelliteClockBias = 0.0,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  PseudorangeFactorArm(

      Key poseKey, Key receiverClockBiasKey,

      double measuredPseudorange, const Point3& satellitePosition,

      const Point3& leverArm, const Pose3& ecef_T_nav,

      double satelliteClockBias = 0.0,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  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;


  bool equals(const NonlinearFactor& expected,

              double tol = 1e-9) const override;


  Vector1 evaluateError(const Pose3& pose,

                        const double& receiverClockBias,

                        OptionalMatrixType H_pose,

                        OptionalMatrixType HreceiverClockBias) const override;


  inline const Point3& leverArm() const { return arm_.b; }


  inline const std::optional<Pose3>& ecefTnav() const { return arm_.ecef_T_nav; }


 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(measurement_);

    ar& BOOST_SERIALIZATION_NVP(satPos_);

    ar& BOOST_SERIALIZATION_NVP(satClkBias_);

    ar& boost::serialization::make_nvp("bL_", arm_.b);

    ar& boost::serialization::make_nvp("ecef_T_nav_", arm_.ecef_T_nav);

  }

#endif

};


template <>


struct traits<PseudorangeFactorArm>

    : public Testable<PseudorangeFactorArm> {};


class GTSAM_EXPORT DifferentialPseudorangeFactorArm

    : public NoiseModelFactorT<Vector1, Pose3, double, double>,

      private PseudorangeBase {

 private:

  typedef NoiseModelFactorT<Vector1, Pose3, double, double> Base;

  gnss::LeverArm arm_;


 public:

  using Base::evaluateError;

  typedef std::shared_ptr<DifferentialPseudorangeFactorArm> shared_ptr;

  typedef DifferentialPseudorangeFactorArm This;


  DifferentialPseudorangeFactorArm()

      : PseudorangeBase{0.0, Point3(0, 0, 0), 0.0} {}

  virtual ~DifferentialPseudorangeFactorArm() = default;


  DifferentialPseudorangeFactorArm(

      Key poseKey, Key receiverClockBiasKey, Key differentialCorrectionKey,

      double measuredPseudorange, const Point3& satellitePosition,

      const Point3& leverArm, double satelliteClockBias = 0.0,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  DifferentialPseudorangeFactorArm(

      Key poseKey, Key receiverClockBiasKey, Key differentialCorrectionKey,

      double measuredPseudorange, const Point3& satellitePosition,

      const Point3& leverArm, const Pose3& ecef_T_nav,

      double satelliteClockBias = 0.0,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  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;

  bool equals(const NonlinearFactor& expected,

              double tol = 1e-9) const override;

  Vector1 evaluateError(const Pose3& pose,

                        const double& receiverClockBias,

                        const double& differentialCorrection,

                        OptionalMatrixType H_pose,

                        OptionalMatrixType HreceiverClockBias,

                        OptionalMatrixType HdifferentialCorrection) const override;


  inline const Point3& leverArm() const { return arm_.b; }

  inline const std::optional<Pose3>& ecefTnav() const { return arm_.ecef_T_nav; }


 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(measurement_);

    ar& BOOST_SERIALIZATION_NVP(satPos_);

    ar& BOOST_SERIALIZATION_NVP(satClkBias_);

    ar& boost::serialization::make_nvp("bL_", arm_.b);

    ar& boost::serialization::make_nvp("ecef_T_nav_", arm_.ecef_T_nav);

  }

#endif

};


template <>


struct traits<DifferentialPseudorangeFactorArm>

    : public Testable<DifferentialPseudorangeFactorArm> {};


class GTSAM_EXPORT DoubleDifferencePseudorangeFactor

    : public NoiseModelFactorN<Point3> {

 private:

  typedef NoiseModelFactorN<Point3> Base;


  gnss::DoubleDifferenceData dd_;


 public:

  // Expose the convenience evaluateError overloads from NoiseModelFactorN

  // (e.g. the no-Jacobian and Matrix& variants used in tests).

  using Base::evaluateError;

  typedef std::shared_ptr<DoubleDifferencePseudorangeFactor> shared_ptr;

  typedef DoubleDifferencePseudorangeFactor This;


  DoubleDifferencePseudorangeFactor() = default;


  virtual ~DoubleDifferencePseudorangeFactor() = default;


  DoubleDifferencePseudorangeFactor(

      Key positionKey,

      double prRovRef, double prBaseRef,

      double prRovTarget, double prBaseTarget,

      const Point3& satRefRov, const Point3& satTargetRov,

      const Point3& satRefBase, const Point3& satTargetBase,

      const Point3& basePos,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  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;


  bool equals(const NonlinearFactor& expected,

              double tol = 1e-9) const override;


  Vector evaluateError(const Point3& pos,

                       OptionalMatrixType H) const override;


 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::make_nvp("prRovRef_", dd_.rovRef);

    ar& boost::serialization::make_nvp("prBaseRef_", dd_.baseRef);

    ar& boost::serialization::make_nvp("prRovTarget_", dd_.rovTarget);

    ar& boost::serialization::make_nvp("prBaseTarget_", dd_.baseTarget);

    ar& boost::serialization::make_nvp("satRefRov_", dd_.satRefRov);

    ar& boost::serialization::make_nvp("satTargetRov_", dd_.satTargetRov);

    ar& boost::serialization::make_nvp("satRefBase_", dd_.satRefBase);

    ar& boost::serialization::make_nvp("satTargetBase_", dd_.satTargetBase);

    ar& boost::serialization::make_nvp("basePos_", dd_.basePos);

  }

#endif

};


template <>


struct traits<DoubleDifferencePseudorangeFactor>

    : public Testable<DoubleDifferencePseudorangeFactor> {};


class GTSAM_EXPORT DoubleDifferencePseudorangeFactorArm

    : public NoiseModelFactorN<Pose3> {

 private:

  typedef NoiseModelFactorN<Pose3> Base;


  gnss::DoubleDifferenceData dd_;

  gnss::LeverArm arm_;


 public:

  // Expose the convenience evaluateError overloads from NoiseModelFactorN

  // (e.g. the no-Jacobian and Matrix& variants used in tests).

  using Base::evaluateError;

  typedef std::shared_ptr<DoubleDifferencePseudorangeFactorArm> shared_ptr;

  typedef DoubleDifferencePseudorangeFactorArm This;


  DoubleDifferencePseudorangeFactorArm() = default;


  virtual ~DoubleDifferencePseudorangeFactorArm() = default;


  DoubleDifferencePseudorangeFactorArm(

      Key poseKey,

      double prRovRef, double prBaseRef,

      double prRovTarget, double prBaseTarget,

      const Point3& satRefRov, const Point3& satTargetRov,

      const Point3& satRefBase, const Point3& satTargetBase,

      const Point3& basePos, const Point3& leverArm,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  DoubleDifferencePseudorangeFactorArm(

      Key poseKey,

      double prRovRef, double prBaseRef,

      double prRovTarget, double prBaseTarget,

      const Point3& satRefRov, const Point3& satTargetRov,

      const Point3& satRefBase, const Point3& satTargetBase,

      const Point3& basePos, const Point3& leverArm,

      const Pose3& ecef_T_nav,

      const SharedNoiseModel& model = noiseModel::Unit::Create(1));


  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;


  bool equals(const NonlinearFactor& expected,

              double tol = 1e-9) const override;


  Vector evaluateError(const Pose3& pose,

                       OptionalMatrixType H_pose) const override;


  inline const Point3& leverArm() const { return arm_.b; }

  inline const std::optional<Pose3>& ecefTnav() const { return arm_.ecef_T_nav; }


 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::make_nvp("prRovRef_", dd_.rovRef);

    ar& boost::serialization::make_nvp("prBaseRef_", dd_.baseRef);

    ar& boost::serialization::make_nvp("prRovTarget_", dd_.rovTarget);

    ar& boost::serialization::make_nvp("prBaseTarget_", dd_.baseTarget);

    ar& boost::serialization::make_nvp("satRefRov_", dd_.satRefRov);

    ar& boost::serialization::make_nvp("satTargetRov_", dd_.satTargetRov);

    ar& boost::serialization::make_nvp("satRefBase_", dd_.satRefBase);

    ar& boost::serialization::make_nvp("satTargetBase_", dd_.satTargetBase);

    ar& boost::serialization::make_nvp("basePos_", dd_.basePos);

    ar& boost::serialization::make_nvp("bL_", arm_.b);

    ar& boost::serialization::make_nvp("ecef_T_nav_", arm_.ecef_T_nav);

  }

#endif

};


template <>


struct traits<DoubleDifferencePseudorangeFactorArm>

    : public Testable<DoubleDifferencePseudorangeFactorArm> {};


}  // namespace gtsam

Point3.h
3D Point

Pose3.h
3D Pose manifold SO(3) x R^3 and group SE(3)

GnssCommon.h
Shared constants and utilities for GNSS factors.

NoiseModelFactorN.h
Base class for noise model factors with N variables.

NonlinearFactor.h
Non-linear factor base classes.

gtsam
Global functions in a separate testing namespace.
Definition chartTesting.h:28

gtsam::DefaultKeyFormatter
KeyFormatter DefaultKeyFormatter
Assign default key formatter.
Definition Key.cpp:30

gtsam::OptionalMatrixType
Matrix * OptionalMatrixType
This typedef will be used everywhere boost::optional<Matrix&> reference was used previously.
Definition NonlinearFactor.h:57

gtsam::NoiseModelFactorN
NoiseModelFactorT< Vector, ValueTypes... > NoiseModelFactorN
Noise model factor with N value types and dynamic-sized error vector.
Definition NoiseModelFactorN.h:561

gtsam::Point3
Vector3 Point3
As of GTSAM 4, in order to make GTSAM more lean, it is now possible to just typedef Point3 to Vector3...
Definition Point3.h:38

gtsam::print
void print(const Matrix &A, const string &s, ostream &stream)
print without optional string, must specify cout yourself
Definition Matrix.cpp:143

gtsam::KeyFormatter
std::function< std::string(Key)> KeyFormatter
Typedef for a function to format a key, i.e. to convert it to a string.
Definition Key.h:35

gtsam::SharedNoiseModel
noiseModel::Base::shared_ptr SharedNoiseModel
Aliases.
Definition NoiseModel.h:846

gtsam::PseudorangeBase
GnssMeasurementBase PseudorangeBase
Base class storing common members for GNSS-related pseudorange factors.
Definition PseudorangeFactor.h:39

gtsam::Key
std::uint64_t Key
Integer nonlinear key type.
Definition types.h:43

gtsam::traits
A manifold defines a space in which there is a notion of a linear tangent space that can be centered ...
Definition Group.h:37

gtsam::equals
Template to create a binary predicate.
Definition Testable.h:112

gtsam::Testable
A helper that implements the traits interface for GTSAM types.
Definition Testable.h:152

gtsam::Pose3
A 3D pose (R,t) : (Rot3,Point3).
Definition Pose3.h:42

gtsam::noiseModel::Unit::Create
static shared_ptr Create(size_t dim)
Create a unit covariance noise model.
Definition NoiseModel.h:673

gtsam::GnssMeasurementBase
Base class storing common members for GNSS measurement factors.
Definition GnssCommon.h:25

gtsam::gnss::DoubleDifferenceData
Shared geometry data for double-difference factors.
Definition GnssCommon.h:74

gtsam::gnss::DoubleDifferenceData::satRefRov
Point3 satRefRov
Ref satellite ECEF at rover time [m].
Definition GnssCommon.h:79

gtsam::gnss::DoubleDifferenceData::satRefBase
Point3 satRefBase
Ref satellite ECEF at base time [m].
Definition GnssCommon.h:81

gtsam::gnss::DoubleDifferenceData::satTargetBase
Point3 satTargetBase
Target satellite ECEF at base time [m].
Definition GnssCommon.h:82

gtsam::gnss::DoubleDifferenceData::baseRef
double baseRef
Base observation for ref satellite [m].
Definition GnssCommon.h:76

gtsam::gnss::DoubleDifferenceData::basePos
Point3 basePos
Base station ECEF position [m].
Definition GnssCommon.h:83

gtsam::gnss::DoubleDifferenceData::satTargetRov
Point3 satTargetRov
Target satellite ECEF at rover time [m].
Definition GnssCommon.h:80

gtsam::gnss::DoubleDifferenceData::baseTarget
double baseTarget
Base observation for target satellite [m].
Definition GnssCommon.h:78

gtsam::gnss::DoubleDifferenceData::rovTarget
double rovTarget
Rover observation for target satellite [m].
Definition GnssCommon.h:77

gtsam::gnss::DoubleDifferenceData::rovRef
double rovRef
Rover observation for ref satellite [m].
Definition GnssCommon.h:75

gtsam::gnss::LeverArm
Lever-arm helper for GNSS factors that key on a body Pose3.
Definition GnssCommon.h:119

gtsam::gnss::LeverArm::b
Point3 b
Lever arm in body frame [m].
Definition GnssCommon.h:120

gtsam::gnss::LeverArm::ecef_T_nav
std::optional< Pose3 > ecef_T_nav
Optional ECEF-from-nav transform.
Definition GnssCommon.h:121

gtsam::PseudorangeFactor
Simplified GNSS pseudorange model for basic positioning problems.
Definition PseudorangeFactor.h:65

gtsam::PseudorangeFactor::PseudorangeFactor
PseudorangeFactor()=default
default constructor - only use for serialization

gtsam::PseudorangeFactor::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Definition PseudorangeFactor.h:102

gtsam::PseudorangeFactor::This
PseudorangeFactor This
Typedef to this class.
Definition PseudorangeFactor.h:77

gtsam::PseudorangeFactor::shared_ptr
std::shared_ptr< PseudorangeFactor > shared_ptr
shorthand for a smart pointer to a factor
Definition PseudorangeFactor.h:74

gtsam::UndifferencedPseudorangeFactor
Undifferenced (raw) PPP pseudorange factor.
Definition PseudorangeFactor.h:166

gtsam::UndifferencedPseudorangeFactor::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition PseudorangeFactor.h:200

gtsam::UndifferencedPseudorangeFactorArm
Undifferenced (raw) PPP pseudorange factor with lever-arm correction.
Definition PseudorangeFactor.h:254

gtsam::UndifferencedPseudorangeFactorArm::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition PseudorangeFactor.h:288

gtsam::DifferentialPseudorangeFactor
Definition PseudorangeFactor.h:357

gtsam::DifferentialPseudorangeFactor::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition PseudorangeFactor.h:375

gtsam::PseudorangeFactorArm
GNSS pseudorange factor with lever arm correction.
Definition PseudorangeFactor.h:431

gtsam::PseudorangeFactorArm::leverArm
const Point3 & leverArm() const
return the lever arm, a position in the body frame
Definition PseudorangeFactor.h:509

gtsam::PseudorangeFactorArm::ecefTnav
const std::optional< Pose3 > & ecefTnav() const
return the optional ecef_T_nav transform
Definition PseudorangeFactor.h:512

gtsam::PseudorangeFactorArm::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Definition PseudorangeFactor.h:489

gtsam::PseudorangeFactorArm::shared_ptr
std::shared_ptr< PseudorangeFactorArm > shared_ptr
shorthand for a smart pointer to a factor
Definition PseudorangeFactor.h:442

gtsam::PseudorangeFactorArm::This
PseudorangeFactorArm This
Typedef to this class.
Definition PseudorangeFactor.h:445

gtsam::PseudorangeFactorArm::PseudorangeFactorArm
PseudorangeFactorArm()
default constructor - only use for serialization
Definition PseudorangeFactor.h:448

gtsam::DifferentialPseudorangeFactorArm
Differentially-corrected pseudorange factor with lever arm correction.
Definition PseudorangeFactor.h:553

gtsam::DifferentialPseudorangeFactorArm::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition PseudorangeFactor.h:580

gtsam::DoubleDifferencePseudorangeFactor
Double-difference pseudorange factor.
Definition PseudorangeFactor.h:648

gtsam::DoubleDifferencePseudorangeFactor::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition PseudorangeFactor.h:687

gtsam::DoubleDifferencePseudorangeFactorArm
Double-difference pseudorange factor with lever arm correction.
Definition PseudorangeFactor.h:733

gtsam::DoubleDifferencePseudorangeFactorArm::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition PseudorangeFactor.h:770

gtsam::NoiseModelFactorT< Vector1, Point3, double >::NoiseModelFactorT
NoiseModelFactorT()
Definition NoiseModelFactorN.h:257

gtsam::NoiseModelFactorT< Vector1, Point3, double >::evaluateError
virtual Vector1 evaluateError(const ValueTypes &... x, OptionalMatrixTypeT< ValueTypes >... H) const=0

gtsam::NonlinearFactor
Nonlinear factor base class.
Definition NonlinearFactor.h:70