gtsam  4.1.0
gtsam
AntiFactor.h
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2 
3  * GTSAM Copyright 2010, Georgia Tech Research Corporation,
4  * Atlanta, Georgia 30332-0415
5  * All Rights Reserved
6  * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
7 
8  * See LICENSE for the license information
9 
10  * -------------------------------------------------------------------------- */
11 
16 #pragma once
17 
18 #include <ostream>
19 
22 
23 namespace gtsam {
24 
31  class AntiFactor: public NonlinearFactor {
32 
33  private:
34 
35  typedef AntiFactor This;
36  typedef NonlinearFactor Base;
37  typedef NonlinearFactor::shared_ptr sharedFactor;
38 
39  sharedFactor factor_;
40 
41  public:
42 
43  // shorthand for a smart pointer to a factor
44  typedef boost::shared_ptr<AntiFactor> shared_ptr;
45 
48 
50  AntiFactor(NonlinearFactor::shared_ptr factor) : Base(factor->keys()), factor_(factor) {}
51 
52  virtual ~AntiFactor() {}
53 
55  gtsam::NonlinearFactor::shared_ptr clone() const override {
56  return boost::static_pointer_cast<gtsam::NonlinearFactor>(
57  gtsam::NonlinearFactor::shared_ptr(new This(*this))); }
58 
62  void print(const std::string& s, const KeyFormatter& keyFormatter = DefaultKeyFormatter) const override {
63  std::cout << s << "AntiFactor version of:" << std::endl;
64  factor_->print(s, keyFormatter);
65  }
66 
68  bool equals(const NonlinearFactor& expected, double tol=1e-9) const override {
69  const This *e = dynamic_cast<const This*> (&expected);
70  return e != nullptr && Base::equals(*e, tol) && this->factor_->equals(*e->factor_, tol);
71  }
72 
80  double error(const Values& c) const override { return -factor_->error(c); }
81 
83  size_t dim() const override { return factor_->dim(); }
84 
89  bool active(const Values& c) const override { return factor_->active(c); }
90 
97  boost::shared_ptr<GaussianFactor> linearize(const Values& c) const override {
98 
99  // Generate the linearized factor from the contained nonlinear factor
100  GaussianFactor::shared_ptr gaussianFactor = factor_->linearize(c);
101 
102  // return the negated version of the factor
103  return gaussianFactor->negate();
104  }
105 
106 
107  private:
108 
111  template<class ARCHIVE>
112  void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
113  ar & boost::serialization::make_nvp("AntiFactor",
114  boost::serialization::base_object<Base>(*this));
115  ar & BOOST_SERIALIZATION_NVP(factor_);
116  }
117  }; // \class AntiFactor
118 
119 }
gtsam::GaussianFactor::shared_ptr
boost::shared_ptr< This > shared_ptr
shared_ptr to this class
Definition: GaussianFactor.h:42
gtsam::AntiFactor::AntiFactor
AntiFactor()
default constructor - only use for serialization
Definition: AntiFactor.h:47
gtsam::AntiFactor::dim
size_t dim() const override
get the dimension of the factor (same as the original factor)
Definition: AntiFactor.h:83
gtsam::AntiFactor::print
void print(const std::string &s, const KeyFormatter &keyFormatter=DefaultKeyFormatter) const override
implement functions needed for Testable
Definition: AntiFactor.h:62
gtsam::AntiFactor::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Definition: AntiFactor.h:55
gtsam::Factor::keys
const KeyVector & keys() const
Access the factor's involved variable keys.
Definition: Factor.h:118
gtsam
Global functions in a separate testing namespace.
Definition: chartTesting.h:28
gtsam::AntiFactor::active
bool active(const Values &c) const override
Checks whether this factor should be used based on a set of values.
Definition: AntiFactor.h:89
gtsam::NonlinearFactor
Nonlinear factor base class.
Definition: NonlinearFactor.h:43
NonlinearFactor.h
Non-linear factor base classes.
gtsam::AntiFactor::error
double error(const Values &c) const override
implement functions needed to derive from Factor
Definition: AntiFactor.h:80
gtsam::KeyFormatter
boost::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::Factor
This is the base class for all factor types.
Definition: Factor.h:55
gtsam::AntiFactor
Definition: AntiFactor.h:31
gtsam::AntiFactor::linearize
boost::shared_ptr< GaussianFactor > linearize(const Values &c) const override
Linearize to a GaussianFactor.
Definition: AntiFactor.h:97
gtsam::AntiFactor::AntiFactor
AntiFactor(NonlinearFactor::shared_ptr factor)
constructor - Creates the equivalent AntiFactor from an existing factor
Definition: AntiFactor.h:50
gtsam::AntiFactor::equals
bool equals(const NonlinearFactor &expected, double tol=1e-9) const override
equals
Definition: AntiFactor.h:68
GaussianFactor.h
A factor with a quadratic error function - a Gaussian.
gtsam::AntiFactor::access
friend class boost::serialization::access
Serialization function.
Definition: AntiFactor.h:110
gtsam::Values
A non-templated config holding any types of Manifold-group elements.
Definition: Values.h:71
gtsam::NonlinearFactor::equals
virtual bool equals(const NonlinearFactor &f, double tol=1e-9) const
Check if two factors are equal.
Definition: NonlinearFactor.cpp:36