12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
gtsam/gtsam.h

3170 lines
110 KiB
C
Raw Normal View History

Added comment support in wrap
2011-12-02 06:06:03 +08:00
/**
Fixed wrapper
2015-07-13 13:49:04 +08:00
Fixed ambiguity issues with returning non-ptr classes, added new copies of functions to gtsam.h and depreciated old ones
2011-12-07 11:05:37 +08:00
* GTSAM Wrap Module Definition
Added comment support in wrap
2011-12-02 06:06:03 +08:00
*
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
* These are the current classes available through the matlab and python wrappers,
Added comment support in wrap
2011-12-02 06:06:03 +08:00
* add more functions/classes as they are available.
*
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
* IMPORTANT: the python wrapper supports keyword arguments for functions/methods. Hence, the
* argument names matter. An implementation restriction is that in overloaded methods
* or functions, arguments of different types *have* to have different names.
*
Added comment support in wrap
2011-12-02 06:06:03 +08:00
* Requirements:
Fixed ambiguity issues with returning non-ptr classes, added new copies of functions to gtsam.h and depreciated old ones
2011-12-07 11:05:37 +08:00
* Classes must start with an uppercase letter
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
* - Can wrap a typedef
Wrapped Ordering::InvertedMap
2012-07-10 02:51:07 +08:00
* Only one Method/Constructor per line, though methods/constructors can extend across multiple lines
Fixed ambiguity issues with returning non-ptr classes, added new copies of functions to gtsam.h and depreciated old ones
2011-12-07 11:05:37 +08:00
* Methods can return
* - Eigen types: Matrix, Vector
Fixed typo in wrap module explanation at top of gtsam.h
2013-01-27 05:22:56 +08:00
* - C/C++ basic types: string, bool, size_t, int, double, char, unsigned char
Fixed ambiguity issues with returning non-ptr classes, added new copies of functions to gtsam.h and depreciated old ones
2011-12-07 11:05:37 +08:00
* - void
* - Any class with which be copied with boost::make_shared()
* - boost::shared_ptr of any object type
Added docs about templates to gtsam.h
2012-07-14 07:19:37 +08:00
* Constructors
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
* - Overloads are supported, but arguments of different types *have* to have different names
Can return abstract base classes from functions in matlab wrapper, i.e. Values::at
2012-07-10 04:19:37 +08:00
* - A class with no constructors can be returned from other functions but not allocated directly in MATLAB
* Methods
make targets for cleaning wrap, comments in gtsam.h
2012-06-24 03:24:57 +08:00
* - Constness has no effect
Merge remote-tracking branch 'svn/branches/wrap_mods' into wrap_mods_inheritance Conflicts: gtsam.h
2012-07-10 04:27:23 +08:00
* - Specify by-value (not reference) return types, even if C++ method returns reference
allow method starting with uppercase letter to be wrapped in matlab. Wrap Pose3's AdjointMap and Adjoint operator
2013-04-22 03:29:41 +08:00
* - Must start with a letter (upper or lowercase)
Can return abstract base classes from functions in matlab wrapper, i.e. Values::at
2012-07-10 04:19:37 +08:00
* - Overloads are supported
* Static methods
* - Must start with a letter (upper or lowercase) and use the "static" keyword
Merge remote-tracking branch 'svn/branches/wrap_mods' into wrap_mods_inheritance Conflicts: gtsam.h
2012-07-10 04:27:23 +08:00
* - The first letter will be made uppercase in the generated MATLAB interface
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
* - Overloads are supported, but arguments of different types *have* to have different names
Added docs about templates to gtsam.h
2012-07-14 07:19:37 +08:00
* Arguments to functions any of
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
* - Eigen types: Matrix, Vector
* - Eigen types and classes as an optionally const reference
Fixing broken functions in matlab wrapper
2012-06-05 04:51:28 +08:00
* - C/C++ basic types: string, bool, size_t, size_t, double, char, unsigned char
Fixed ambiguity issues with returning non-ptr classes, added new copies of functions to gtsam.h and depreciated old ones
2011-12-07 11:05:37 +08:00
* - Any class with which be copied with boost::make_shared() (except Eigen)
* - boost::shared_ptr of any object type (except Eigen)
* Comments can use either C++ or C style, with multiple lines
Added documentation on namespaces to gtsam.h
2011-12-09 04:58:06 +08:00
* Namespace definitions
* - Names of namespaces must start with a lowercase letter
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
* - start a namespace with "namespace {"
* - end a namespace with exactly "}"
* - Namespaces can be nested
Added documentation on namespaces to gtsam.h
2011-12-09 04:58:06 +08:00
* Namespace usage
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
* - Namespaces can be specified for classes in arguments and return values
* - In each case, the namespace must be fully specified, e.g., "namespace1::namespace2::ClassName"
Removed extraneous headers that were previously needed for wrap, added start of simulated2D and simulated2DOriented domains to gtsam.h, more wrap documentation
2011-12-10 00:36:50 +08:00
* Includes in C++ wrappers
Simplified include handling in wrap: no more default includes, includes are not associated with a class or a namespace.
2012-07-18 02:30:02 +08:00
* - All includes will be collected and added in a single file
* - All namespaces must have angle brackets: <path>
* - No default includes will be added
Some additional cleanup in wrap
2012-07-24 02:24:39 +08:00
* Global/Namespace functions
* - Functions specified outside of a class are global
* - Can be overloaded with different arguments
* - Can have multiple functions of the same name in different namespaces
Can return abstract base classes from functions in matlab wrapper, i.e. Values::at
2012-07-10 04:19:37 +08:00
* Using classes defined in other modules
documentation updates in gtsam.h
2011-12-16 05:27:08 +08:00
* - If you are using a class 'OtherClass' not wrapped in this definition file, add "class OtherClass;" to avoid a dependency error
Can return abstract base classes from functions in matlab wrapper, i.e. Values::at
2012-07-10 04:19:37 +08:00
* Virtual inheritance
Added clone() to BayesTree to allow for full inheritance, wrapped GaussianBayesTree and made GaussianISAM inherit from GaussianBayesTree
2012-09-11 01:00:02 +08:00
* - Specify fully-qualified base classes, i.e. "virtual class Derived : ns::Base {" where "ns" is the namespace
* - Mark with 'virtual' keyword, e.g. "virtual class Base {", and also "virtual class Derived : ns::Base {"
* - Forward declarations must also be marked virtual, e.g. "virtual class ns::Base;" and
* also "virtual class ns::Derived;"
Can return abstract base classes from functions in matlab wrapper, i.e. Values::at
2012-07-10 04:19:37 +08:00
* - Pure virtual (abstract) classes should list no constructors in this interface file
* - Virtual classes must have a clone() function in C++ (though it does not have to be included
* in the MATLAB interface). clone() will be called whenever an object copy is needed, instead
* of using the copy constructor (which is used for non-virtual objects).
Added clone() to BayesTree to allow for full inheritance, wrapped GaussianBayesTree and made GaussianISAM inherit from GaussianBayesTree
2012-09-11 01:00:02 +08:00
* - Signature of clone function - will be called virtually, so must appear at least at the top of the inheritance tree
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
* virtual boost::shared_ptr<CLASS_NAME> clone() const;
Added wrapping for serialization to/from file functions
2013-06-13 22:29:32 +08:00
* Class Templates
Added docs about templates to gtsam.h
2012-07-14 07:19:37 +08:00
* - Basic templates are supported either with an explicit list of types to instantiate,
* e.g. template<T = {gtsam::Pose2, gtsam::Rot2, gtsam::Point3}> class Class1 { ... };
* or with typedefs, e.g.
* template<T, U> class Class2 { ... };
* typedef Class2<Type1, Type2> MyInstantiatedClass;
Added 'This' keyword in wrap templates to substitute instantiated class
2012-07-24 05:27:36 +08:00
* - In the class definition, appearances of the template argument(s) will be replaced with their
* instantiated types, e.g. 'void setValue(const T& value);'.
* - To refer to the instantiation of the template class itself, use 'This', i.e. 'static This Create();'
Added docs about templates to gtsam.h
2012-07-14 07:19:37 +08:00
* - To create new instantiations in other modules, you must copy-and-paste the whole class definition
* into the new module, but use only your new instantiation types.
* - When forward-declaring template instantiations, use the generated/typedefed name, e.g.
* class gtsam::Class1Pose2;
* class gtsam::MyInstantiatedClass;
Added instructions to gtsam.h
2013-06-20 01:50:10 +08:00
* Boost.serialization within Matlab:
* - you need to mark classes as being serializable in the markup file (see this file for an example).
* - There are two options currently, depending on the class. To "mark" a class as serializable,
* add a function with a particular signature so that wrap will catch it.
* - Add "void serialize()" to a class to create serialization functions for a class.
* Adding this flag subsumes the serializable() flag below. Requirements:
* - A default constructor must be publicly accessible
* - Must not be an abstract base class
* - The class must have an actual boost.serialization serialize() function.
* - Add "void serializable()" to a class if you only want the class to be serialized as a
* part of a container (such as noisemodel). This version does not require a publicly
* accessible default constructor.
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
* Forward declarations and class definitions for Cython:
* - Need to specify the base class (both this forward class and base class are declared in an external cython header)
* This is so Cython can generate proper inheritance.
* Example when wrapping a gtsam-based project:
* // forward declarations
* virtual class gtsam::NonlinearFactor
* virtual class gtsam::NoiseModelFactor : gtsam::NonlinearFactor
* // class definition
* #include <MyFactor.h>
* virtual class MyFactor : gtsam::NoiseModelFactor {...};
* - *DO NOT* re-define overriden function already declared in the external (forward-declared) base class
* - This will cause an ambiguity problem in Cython pxd header file
Fixed ambiguity issues with returning non-ptr classes, added new copies of functions to gtsam.h and depreciated old ones
2011-12-07 11:05:37 +08:00
*/
/**
* Status:
Removed wrap function duplicates due to shared_ptr, removed the wrapping functions inside geometry classes, added named constructors to the wrappable functions
2011-12-07 23:23:20 +08:00
* - TODO: default values for arguments
Added wrapping for serialization to/from file functions
2013-06-13 22:29:32 +08:00
* - WORKAROUND: make multiple versions of the same function for different configurations of default arguments
Matlab wrapped classes now live within the gtsam namespace, meaning you have to use gtsamPose2 instead of just Pose2 in Matlab. This fixes the Point2 and Point3 issues we had with Matlab 2011b. promote pose2SLAM planarSLAM etc. namespaces to be next to gtsam instead of within
2012-01-31 06:00:13 +08:00
* - TODO: Handle gtsam::Rot3M conversions to quaternions
Added wrapping for serialization to/from file functions
2013-06-13 22:29:32 +08:00
* - TODO: Parse return of const ref arguments
* - TODO: Parse std::string variants and convert directly to special string
* - TODO: Add enum support
* - TODO: Add generalized serialization support via boost.serialization with hooks to matlab save/load
Added comment support in wrap
2011-12-02 06:06:03 +08:00
*/
Overload for insertProjectionFactors in matlab utilities
2012-12-18 06:30:54 +08:00
namespace gtsam {
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
// Actually a FastList<Key>
#include <gtsam/inference/Key.h>
class KeyList {
KeyList();
KeyList(const gtsam::KeyList& other);
// Note: no print function
// common STL methods
size_t size() const;
bool empty() const;
void clear();
// structure specific methods
size_t front() const;
size_t back() const;
void push_back(size_t key);
void push_front(size_t key);
void pop_back();
void pop_front();
void sort();
void remove(size_t key);
void serialize() const;
};
// Actually a FastSet<Key>
class KeySet {
KeySet();
Constructor overloads are supported, but arguments *have* to have different names
2017-08-07 05:57:40 +08:00
KeySet(const gtsam::KeySet& set);
KeySet(const gtsam::KeyVector& vector);
KeySet(const gtsam::KeyList& list);
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::KeySet& other) const;
// common STL methods
size_t size() const;
bool empty() const;
void clear();
// structure specific methods
void insert(size_t key);
fix constness
2017-10-09 10:06:44 +08:00
void merge(const gtsam::KeySet& other);
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
bool erase(size_t key); // returns true if value was removed
bool count(size_t key) const; // returns true if value exists
void serialize() const;
};
// Actually a vector<Key>
class KeyVector {
KeyVector();
KeyVector(const gtsam::KeyVector& other);
// Note: no print function
// common STL methods
size_t size() const;
bool empty() const;
void clear();
// structure specific methods
size_t at(size_t i) const;
size_t front() const;
size_t back() const;
void push_back(size_t key) const;
void serialize() const;
};
// Actually a FastMap<Key,int>
class KeyGroupMap {
KeyGroupMap();
// Note: no print function
// common STL methods
size_t size() const;
bool empty() const;
void clear();
// structure specific methods
size_t at(size_t key) const;
int erase(size_t key);
bool insert2(size_t key, int val);
};
Type for Factor indices, dual to "Key" This avoids a couple of confusing uses of KeySet to refer to lists of Factors, and makes code more readable where formerly using size_t to index factors.
2019-02-27 15:50:50 +08:00
// Actually a FastSet<FactorIndex>
class FactorIndexSet {
FactorIndexSet();
FactorIndexSet(const gtsam::FactorIndexSet& set);
// common STL methods
size_t size() const;
bool empty() const;
void clear();
// structure specific methods
prefer auto in range for loops
2019-04-09 06:29:31 +08:00
void insert(size_t factorIndex);
bool erase(size_t factorIndex); // returns true if value was removed
bool count(size_t factorIndex) const; // returns true if value exists
Type for Factor indices, dual to "Key" This avoids a couple of confusing uses of KeySet to refer to lists of Factors, and makes code more readable where formerly using size_t to index factors.
2019-02-27 15:50:50 +08:00
};
// Actually a vector<FactorIndex>
class FactorIndices {
FactorIndices();
FactorIndices(const gtsam::FactorIndices& other);
// common STL methods
size_t size() const;
bool empty() const;
void clear();
// structure specific methods
size_t at(size_t i) const;
size_t front() const;
size_t back() const;
prefer auto in range for loops
2019-04-09 06:29:31 +08:00
void push_back(size_t factorIndex) const;
Type for Factor indices, dual to "Key" This avoids a couple of confusing uses of KeySet to refer to lists of Factors, and makes code more readable where formerly using size_t to index factors.
2019-02-27 15:50:50 +08:00
};
Added DSFMap to wrapper, as well as IndexPair
2019-04-18 08:05:28 +08:00
Additional Kalman filter constructor takes covariance
2012-01-18 04:04:37 +08:00
//*************************************************************************
// base
//*************************************************************************
Added example namespace function to gtsam - works in matlab
2012-07-24 02:24:37 +08:00
/** gtsam namespace functions */
Added DSFMap to wrapper, as well as IndexPair
2019-04-18 08:05:28 +08:00
[ci skip] Added free function to check if compiled library is debug version or not
2019-06-13 05:50:51 +08:00
#include <gtsam/base/debug.h>
bool isDebugVersion();
Added DSFMap to wrapper, as well as IndexPair
2019-04-18 08:05:28 +08:00
#include <gtsam/base/DSFMap.h>
Added Welsch model to gtsam.h
2019-08-29 23:15:00 +08:00
class IndexPair {
IndexPair();
IndexPair(size_t i, size_t j);
Added DSFMap to wrapper, as well as IndexPair
2019-04-18 08:05:28 +08:00
size_t i() const;
size_t j() const;
};
template<KEY = {gtsam::IndexPair}>
class DSFMap {
DSFMap();
KEY find(const KEY& key) const;
void merge(const KEY& x, const KEY& y);
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/base/Matrix.h>
Added example namespace function to gtsam - works in matlab
2012-07-24 02:24:37 +08:00
bool linear_independent(Matrix A, Matrix B, double tol);
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/base/Value.h>
Can return abstract base classes from functions in matlab wrapper, i.e. Values::at
2012-07-10 04:19:37 +08:00
virtual class Value {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// No constructors because this is an abstract class
wrap_mods_inheritance branch - Can now pass derived classes in as base class arguments (i.e. pass gtsamPose2 where gtsamValues.insert expects gtsamValue)
2012-07-09 08:02:43 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Testable
void print(string s) const;
wrap_mods_inheritance branch: in progress with inheritance in matlab wrapper
2012-07-08 20:27:39 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Manifold
size_t dim() const;
wrap_mods_inheritance branch: in progress with inheritance in matlab wrapper
2012-07-08 20:27:39 +08:00
};
Adding GenericValue for Values serialization, as suggested by Callum Robinson and Mike Sheffler in issue #398
2018-12-31 03:34:55 +08:00
#include <gtsam/base/GenericValue.h>
replaced/appended all calls to SimpleCamera with PinholeCameraCal3_S2
2020-02-22 08:42:55 +08:00
template<T = {Vector, gtsam::Point2, gtsam::Point3, gtsam::Rot2, gtsam::Rot3, gtsam::Pose2, gtsam::Pose3, gtsam::StereoPoint2, gtsam::Cal3_S2, gtsam::CalibratedCamera, gtsam::SimpleCamera, gtsam::imuBias::ConstantBias}>
Adding GenericValue for Values serialization, as suggested by Callum Robinson and Mike Sheffler in issue #398
2018-12-31 03:34:55 +08:00
virtual class GenericValue : gtsam::Value {
void serializable() const;
};
removed redundancy in naming
2015-07-10 02:28:59 +08:00
#include <gtsam/base/deprecated/LieScalar.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class LieScalar {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard constructors
LieScalar();
LieScalar(double d);
Wrapped LieScalar
2012-08-11 10:53:56 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard interface
double value() const;
Wrapped LieScalar
2012-08-11 10:53:56 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::LieScalar& expected, double tol) const;
Wrapped LieScalar
2012-08-11 10:53:56 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Group
static gtsam::LieScalar identity();
gtsam::LieScalar inverse() const;
gtsam::LieScalar compose(const gtsam::LieScalar& p) const;
gtsam::LieScalar between(const gtsam::LieScalar& l2) const;
Wrapped LieScalar
2012-08-11 10:53:56 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Manifold
size_t dim() const;
gtsam::LieScalar retract(Vector v) const;
Vector localCoordinates(const gtsam::LieScalar& t2) const;
Wrapped LieScalar
2012-08-11 10:53:56 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Lie group
static gtsam::LieScalar Expmap(Vector v);
static Vector Logmap(const gtsam::LieScalar& p);
Wrapped LieScalar
2012-08-11 10:53:56 +08:00
};
removed redundancy in naming
2015-07-10 02:28:59 +08:00
#include <gtsam/base/deprecated/LieVector.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class LieVector {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard constructors
LieVector();
LieVector(Vector v);
wrap LieVector
2012-06-19 02:12:19 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard interface
Vector vector() const;
wrap LieVector
2012-06-19 02:12:19 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::LieVector& expected, double tol) const;
wrap LieVector
2012-06-19 02:12:19 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Group
static gtsam::LieVector identity();
gtsam::LieVector inverse() const;
gtsam::LieVector compose(const gtsam::LieVector& p) const;
gtsam::LieVector between(const gtsam::LieVector& l2) const;
wrap LieVector
2012-06-19 02:12:19 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Manifold
size_t dim() const;
gtsam::LieVector retract(Vector v) const;
Vector localCoordinates(const gtsam::LieVector& t2) const;
wrap LieVector
2012-06-19 02:12:19 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Lie group
static gtsam::LieVector Expmap(Vector v);
static Vector Logmap(const gtsam::LieVector& p);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
wrap LieVector
2012-06-19 02:12:19 +08:00
};
removed redundancy in naming
2015-07-10 02:28:59 +08:00
#include <gtsam/base/deprecated/LieMatrix.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class LieMatrix {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard constructors
LieMatrix();
LieMatrix(Matrix v);
Wrapped LieMatrix
2012-07-17 23:51:32 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard interface
Matrix matrix() const;
Wrapped LieMatrix
2012-07-17 23:51:32 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::LieMatrix& expected, double tol) const;
Wrapped LieMatrix
2012-07-17 23:51:32 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Group
static gtsam::LieMatrix identity();
gtsam::LieMatrix inverse() const;
gtsam::LieMatrix compose(const gtsam::LieMatrix& p) const;
gtsam::LieMatrix between(const gtsam::LieMatrix& l2) const;
Wrapped LieMatrix
2012-07-17 23:51:32 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Manifold
size_t dim() const;
gtsam::LieMatrix retract(Vector v) const;
Vector localCoordinates(const gtsam::LieMatrix & t2) const;
Wrapped LieMatrix
2012-07-17 23:51:32 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Lie group
static gtsam::LieMatrix Expmap(Vector v);
static Vector Logmap(const gtsam::LieMatrix& p);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Wrapped LieMatrix
2012-07-17 23:51:32 +08:00
};
Additional Kalman filter constructor takes covariance
2012-01-18 04:04:37 +08:00
//*************************************************************************
// geometry
//*************************************************************************
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/Point2.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class Point2 {
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Constructors
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Point2();
Point2(double x, double y);
Point2(Vector v);
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Testable
void print(string s) const;
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
bool equals(const gtsam::Point2& point, double tol) const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Group
static gtsam::Point2 identity();
// Standard Interface
double x() const;
wrapped dist() for Point2
2012-07-31 04:16:54 +08:00
double y() const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
Vector vector() const;
Derive Point2 from Vector2 and deprecate a number of methods
2016-06-06 14:52:04 +08:00
double distance(const gtsam::Point2& p2) const;
Overload for insertProjectionFactors in matlab utilities
2012-12-18 06:30:54 +08:00
double norm() const;
Rearranged serialization test to use new interface, added serialize() flags to Point2 and Values. Serialzing values fails - now to add export commands
2013-06-20 01:50:01 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Added back the matlab interface to gtsam
2011-10-14 02:41:56 +08:00
};
Moved Point2Vector wrapper from gtsam_unstable.h to gtsam.h
2015-05-04 08:31:08 +08:00
// std::vector<gtsam::Point2>
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/Point2.h>
Moved Point2Vector wrapper from gtsam_unstable.h to gtsam.h
2015-05-04 08:31:08 +08:00
class Point2Vector
{
// Constructors
Point2Vector();
Point2Vector(const gtsam::Point2Vector& v);
//Capacity
size_t size() const;
size_t max_size() const;
void resize(size_t sz);
size_t capacity() const;
bool empty() const;
void reserve(size_t n);
//Element access
gtsam::Point2 at(size_t n) const;
gtsam::Point2 front() const;
gtsam::Point2 back() const;
//Modifiers
void assign(size_t n, const gtsam::Point2& u);
void push_back(const gtsam::Point2& x);
void pop_back();
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/StereoPoint2.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class StereoPoint2 {
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Constructors
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
StereoPoint2();
StereoPoint2(double uL, double uR, double v);
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::StereoPoint2& point, double tol) const;
// Group
static gtsam::StereoPoint2 identity();
gtsam::StereoPoint2 inverse() const;
gtsam::StereoPoint2 compose(const gtsam::StereoPoint2& p2) const;
gtsam::StereoPoint2 between(const gtsam::StereoPoint2& p2) const;
// Manifold
gtsam::StereoPoint2 retract(Vector v) const;
Vector localCoordinates(const gtsam::StereoPoint2& p) const;
// Lie Group
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
static gtsam::StereoPoint2 Expmap(Vector v);
static Vector Logmap(const gtsam::StereoPoint2& p);
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Interface
Vector vector() const;
add accessors to StereoPoint2
2013-07-26 01:01:33 +08:00
double uL() const;
double uR() const;
double v() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/Point3.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class Point3 {
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Constructors
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Point3();
Point3(double x, double y, double z);
Point3(Vector v);
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::Point3& p, double tol) const;
// Group
static gtsam::Point3 identity();
// Standard Interface
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Vector vector() const;
double x() const;
double y() const;
double z() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
unbroke a number of classes in linear, testing them with gtsam_experimental/matlab code
2011-10-21 13:07:35 +08:00
};
Added back the matlab interface to gtsam
2011-10-14 02:41:56 +08:00
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/Rot2.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class Rot2 {
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Constructors and Named Constructors
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Rot2();
Rot2(double theta);
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
static gtsam::Rot2 fromAngle(double theta);
static gtsam::Rot2 fromDegrees(double theta);
static gtsam::Rot2 fromCosSin(double c, double s);
// Testable
void print(string s) const;
bool equals(const gtsam::Rot2& rot, double tol) const;
// Group
static gtsam::Rot2 identity();
Fixing broken functions in matlab wrapper
2012-06-05 04:51:28 +08:00
gtsam::Rot2 inverse();
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
gtsam::Rot2 compose(const gtsam::Rot2& p2) const;
gtsam::Rot2 between(const gtsam::Rot2& p2) const;
// Manifold
gtsam::Rot2 retract(Vector v) const;
Vector localCoordinates(const gtsam::Rot2& p) const;
// Lie Group
static gtsam::Rot2 Expmap(Vector v);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static Vector Logmap(const gtsam::Rot2& p);
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Group Action on Point2
gtsam::Point2 rotate(const gtsam::Point2& point) const;
gtsam::Point2 unrotate(const gtsam::Point2& point) const;
// Standard Interface
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::Rot2 relativeBearing(const gtsam::Point2& d); // Ignoring derivative
static gtsam::Rot2 atan2(double y, double x);
double theta() const;
double degrees() const;
double c() const;
double s() const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
Matrix matrix() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
added Rot2 class
2011-10-14 12:43:40 +08:00
};
Wrapped SO(3), SO(4) and new factor, and added SO(4) tests in python
2019-04-17 12:07:38 +08:00
#include <gtsam/geometry/SO3.h>
class SO3 {
// Standard Constructors
SO3();
SO3(Matrix R);
Python tests
2019-05-15 08:43:44 +08:00
static gtsam::SO3 FromMatrix(Matrix R);
Wrapped SO(3), SO(4) and new factor, and added SO(4) tests in python
2019-04-17 12:07:38 +08:00
static gtsam::SO3 AxisAngle(const Vector axis, double theta);
static gtsam::SO3 ClosestTo(const Matrix M);
// Testable
void print(string s) const;
bool equals(const gtsam::SO3& other, double tol) const;
// Group
static gtsam::SO3 identity();
gtsam::SO3 inverse() const;
gtsam::SO3 between(const gtsam::SO3& R) const;
gtsam::SO3 compose(const gtsam::SO3& R) const;
// Manifold
gtsam::SO3 retract(Vector v) const;
Vector localCoordinates(const gtsam::SO3& R) const;
static gtsam::SO3 Expmap(Vector v);
// Other methods
Vector vec() const;
Matrix matrix() const;
};
#include <gtsam/geometry/SO4.h>
class SO4 {
// Standard Constructors
SO4();
SO4(Matrix R);
Python tests
2019-05-15 08:43:44 +08:00
static gtsam::SO4 FromMatrix(Matrix R);
Wrapped SO(3), SO(4) and new factor, and added SO(4) tests in python
2019-04-17 12:07:38 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::SO4& other, double tol) const;
// Group
static gtsam::SO4 identity();
gtsam::SO4 inverse() const;
gtsam::SO4 between(const gtsam::SO4& Q) const;
gtsam::SO4 compose(const gtsam::SO4& Q) const;
// Manifold
gtsam::SO4 retract(Vector v) const;
Vector localCoordinates(const gtsam::SO4& Q) const;
static gtsam::SO4 Expmap(Vector v);
// Other methods
Vector vec() const;
Matrix matrix() const;
};
Made constructor explicit, expose SOn in wrapper
2019-04-21 04:49:20 +08:00
#include <gtsam/geometry/SOn.h>
class SOn {
// Standard Constructors
SOn(size_t n);
Python tests
2019-05-15 08:43:44 +08:00
static gtsam::SOn FromMatrix(Matrix R);
// Testable
void print(string s) const;
bool equals(const gtsam::SOn& other, double tol) const;
// Group
static gtsam::SOn identity();
gtsam::SOn inverse() const;
gtsam::SOn between(const gtsam::SOn& Q) const;
gtsam::SOn compose(const gtsam::SOn& Q) const;
// Manifold
gtsam::SOn retract(Vector v) const;
Vector localCoordinates(const gtsam::SOn& Q) const;
static gtsam::SOn Expmap(Vector v);
Made constructor explicit, expose SOn in wrapper
2019-04-21 04:49:20 +08:00
// Other methods
Vector vec() const;
Matrix matrix() const;
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/Rot3.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class Rot3 {
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Constructors and Named Constructors
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Rot3();
Rot3(Matrix R);
fix gtsam.h to compile with matlab
2017-08-16 04:39:25 +08:00
Rot3(const gtsam::Point3& col1, const gtsam::Point3& col2, const gtsam::Point3& col3);
Added missing Rot3 constructors
2017-08-07 04:23:29 +08:00
Rot3(double R11, double R12, double R13,
double R21, double R22, double R23,
double R31, double R32, double R33);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::Rot3 Rx(double t);
static gtsam::Rot3 Ry(double t);
static gtsam::Rot3 Rz(double t);
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
static gtsam::Rot3 RzRyRx(double x, double y, double z);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::Rot3 RzRyRx(Vector xyz);
Fix small bugs with MATLAB wrapping
2016-01-28 01:24:49 +08:00
static gtsam::Rot3 Yaw(double t); // positive yaw is to right (as in aircraft heading)
static gtsam::Rot3 Pitch(double t); // positive pitch is up (increasing aircraft altitude)
static gtsam::Rot3 Roll(double t); // positive roll is to right (increasing yaw in aircraft)
static gtsam::Rot3 Ypr(double y, double p, double r);
static gtsam::Rot3 Quaternion(double w, double x, double y, double z);
wrap AxisAngle constructor for rotations
2020-03-17 11:33:55 +08:00
static gtsam::Rot3 AxisAngle(const gtsam::Point3& axis, double angle);
switch to Rodrigues everywhere
2015-07-06 07:11:04 +08:00
static gtsam::Rot3 Rodrigues(Vector v);
Added more tests
2017-08-07 06:59:24 +08:00
static gtsam::Rot3 Rodrigues(double wx, double wy, double wz);
Wrapped SO(3), SO(4) and new factor, and added SO(4) tests in python
2019-04-17 12:07:38 +08:00
static gtsam::Rot3 ClosestTo(const Matrix M);
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Testable
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void print(string s) const;
bool equals(const gtsam::Rot3& rot, double tol) const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Group
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::Rot3 identity();
Overload for insertProjectionFactors in matlab utilities
2012-12-18 06:30:54 +08:00
gtsam::Rot3 inverse() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::Rot3 compose(const gtsam::Rot3& p2) const;
gtsam::Rot3 between(const gtsam::Rot3& p2) const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Manifold
Commented out MATLAB wrap Rot3::retractCayley because it does not exist in quaternion mode
2013-06-06 13:01:16 +08:00
//gtsam::Rot3 retractCayley(Vector v) const; // FIXME, does not exist in both Matrix and Quaternion options
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
gtsam::Rot3 retract(Vector v) const;
Vector localCoordinates(const gtsam::Rot3& p) const;
// Group Action on Point3
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::Point3 rotate(const gtsam::Point3& p) const;
gtsam::Point3 unrotate(const gtsam::Point3& p) const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Interface
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::Rot3 Expmap(Vector v);
static Vector Logmap(const gtsam::Rot3& p);
Matrix matrix() const;
Matrix transpose() const;
gtsam::Point3 column(size_t index) const;
Vector xyz() const;
Vector ypr() const;
Vector rpy() const;
double roll() const;
double pitch() const;
double yaw() const;
static function & method for axis-angle with improved tests and fix for sign ambiguity
2020-03-09 05:07:40 +08:00
pair<gtsam::Unit3, double> axisAngle() const;
Removed wrap function duplicates due to shared_ptr, removed the wrapping functions inside geometry classes, added named constructors to the wrappable functions
2011-12-07 23:23:20 +08:00
// Vector toQuaternion() const; // FIXME: Can't cast to Vector properly
Added function to convert from a Rot3 to a vector quaternion that works in matlab. Fixed plot2DTrajectory to actually plot poses when there are no marginals
2013-03-26 01:58:11 +08:00
Vector quaternion() const;
wrap Rot3 slerp function to allow for rotation interpolation
2020-02-26 11:10:42 +08:00
gtsam::Rot3 slerp(double t, const gtsam::Rot3& other) const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Formatting and comments, adding Rot3 and Pose3 to matlab interface
2011-12-01 09:59:34 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/Pose2.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class Pose2 {
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Constructor
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Pose2();
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
Pose2(const gtsam::Pose2& other);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Pose2(double x, double y, double theta);
Pose2(double theta, const gtsam::Point2& t);
Pose2(const gtsam::Rot2& r, const gtsam::Point2& t);
Pose2(Vector v);
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::Pose2& pose, double tol) const;
// Group
static gtsam::Pose2 identity();
gtsam::Pose2 inverse() const;
gtsam::Pose2 compose(const gtsam::Pose2& p2) const;
gtsam::Pose2 between(const gtsam::Pose2& p2) const;
// Manifold
gtsam::Pose2 retract(Vector v) const;
Vector localCoordinates(const gtsam::Pose2& p) const;
// Lie Group
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::Pose2 Expmap(Vector v);
static Vector Logmap(const gtsam::Pose2& p);
Added adjoint operators etc.
2019-01-01 04:37:31 +08:00
static Matrix ExpmapDerivative(Vector v);
static Matrix LogmapDerivative(const gtsam::Pose2& v);
change Pose2::adjointMap and adjoint to Pose2::AdjointMap and Adjoint to make it consistent with Pose3 and standard Lie group notation
2013-05-01 01:20:23 +08:00
Matrix AdjointMap() const;
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
Vector Adjoint(Vector xi) const;
Added underscore to case conflicts until wrap can handle this.
2019-02-11 23:44:24 +08:00
static Matrix adjointMap_(Vector v);
Fixed static issue
2019-02-11 23:52:36 +08:00
static Vector adjoint_(Vector xi, Vector y);
static Vector adjointTranspose(Vector xi, Vector y);
Fixing broken functions in matlab wrapper
2012-06-05 04:51:28 +08:00
static Matrix wedge(double vx, double vy, double w);
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Group Actions on Point2
Pose3 naming convention
2019-05-17 02:33:58 +08:00
gtsam::Point2 transformFrom(const gtsam::Point2& p) const;
gtsam::Point2 transformTo(const gtsam::Point2& p) const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Interface
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
double x() const;
double y() const;
double theta() const;
gtsam::Rot2 bearing(const gtsam::Point2& point) const;
double range(const gtsam::Point2& point) const;
gtsam::Point2 translation() const;
gtsam::Rot2 rotation() const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
Matrix matrix() const;
Adding codegen components for serialization - in progress
2013-06-20 01:49:57 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
unbroke a number of classes in linear, testing them with gtsam_experimental/matlab code
2011-10-21 13:07:35 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/Pose3.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class Pose3 {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard Constructors
Pose3();
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
Pose3(const gtsam::Pose3& other);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Pose3(const gtsam::Rot3& r, const gtsam::Point3& t);
Pose3(const gtsam::Pose2& pose2); // FIXME: shadows Pose3(Pose3 pose)
Constructor overloads are supported, but arguments *have* to have different names
2017-08-07 05:57:40 +08:00
Pose3(Matrix mat);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::Pose3& pose, double tol) const;
// Group
static gtsam::Pose3 identity();
gtsam::Pose3 inverse() const;
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
gtsam::Pose3 compose(const gtsam::Pose3& pose) const;
gtsam::Pose3 between(const gtsam::Pose3& pose) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Manifold
gtsam::Pose3 retract(Vector v) const;
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
Vector localCoordinates(const gtsam::Pose3& pose) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Lie Group
static gtsam::Pose3 Expmap(Vector v);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
static Vector Logmap(const gtsam::Pose3& pose);
allow method starting with uppercase letter to be wrapped in matlab. Wrap Pose3's AdjointMap and Adjoint operator
2013-04-22 03:29:41 +08:00
Matrix AdjointMap() const;
Vector Adjoint(Vector xi) const;
Added underscore to case conflicts until wrap can handle this.
2019-02-11 23:44:24 +08:00
static Matrix adjointMap_(Vector xi);
static Vector adjoint_(Vector xi, Vector y);
Added adjoint operators etc.
2019-01-01 04:37:31 +08:00
static Vector adjointTranspose(Vector xi, Vector y);
static Matrix ExpmapDerivative(Vector xi);
static Matrix LogmapDerivative(const gtsam::Pose3& xi);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static Matrix wedge(double wx, double wy, double wz, double vx, double vy, double vz);
// Group Action on Point3
Pose3 naming convention
2019-05-17 02:33:58 +08:00
gtsam::Point3 transformFrom(const gtsam::Point3& point) const;
gtsam::Point3 transformTo(const gtsam::Point3& point) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard Interface
gtsam::Rot3 rotation() const;
gtsam::Point3 translation() const;
double x() const;
double y() const;
double z() const;
Matrix matrix() const;
Pose3 naming convention
2019-05-17 02:33:58 +08:00
gtsam::Pose3 transformPoseFrom(const gtsam::Pose3& pose) const;
gtsam::Pose3 transformPoseTo(const gtsam::Pose3& pose) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
double range(const gtsam::Point3& point);
double range(const gtsam::Pose3& pose);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Formatting and comments, adding Rot3 and Pose3 to matlab interface
2011-12-01 09:59:34 +08:00
};
Added Pose3Vector
2015-05-04 08:32:13 +08:00
// std::vector<gtsam::Pose3>
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/Pose3.h>
Added Pose3Vector
2015-05-04 08:32:13 +08:00
class Pose3Vector
{
Pose3Vector();
size_t size() const;
bool empty() const;
gtsam::Pose3 at(size_t n) const;
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
void push_back(const gtsam::Pose3& pose);
Added Pose3Vector
2015-05-04 08:32:13 +08:00
};
Rename Sphere2 -> Unit3
2014-02-23 05:20:28 +08:00
#include <gtsam/geometry/Unit3.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class Unit3 {
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
// Standard Constructors
Rename Sphere2 -> Unit3
2014-02-23 05:20:28 +08:00
Unit3();
Unit3(const gtsam::Point3& pose);
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
// Testable
void print(string s) const;
Rename Sphere2 -> Unit3
2014-02-23 05:20:28 +08:00
bool equals(const gtsam::Unit3& pose, double tol) const;
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
// Other functionality
new constructor, getBasis->basis, rotate and distance
2013-12-18 11:11:58 +08:00
Matrix basis() const;
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
Matrix skew() const;
retrieve Point3 from Unit3 in wrapper code
2020-01-22 06:59:44 +08:00
gtsam::Point3 point3() const;
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
// Manifold
static size_t Dim();
size_t dim() const;
Rename Sphere2 -> Unit3
2014-02-23 05:20:28 +08:00
gtsam::Unit3 retract(Vector v) const;
Vector localCoordinates(const gtsam::Unit3& s) const;
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
};
#include <gtsam/geometry/EssentialMatrix.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class EssentialMatrix {
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
// Standard Constructors
Rename Sphere2 -> Unit3
2014-02-23 05:20:28 +08:00
EssentialMatrix(const gtsam::Rot3& aRb, const gtsam::Unit3& aTb);
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::EssentialMatrix& pose, double tol) const;
// Manifold
static size_t Dim();
size_t dim() const;
gtsam::EssentialMatrix retract(Vector v) const;
Vector localCoordinates(const gtsam::EssentialMatrix& s) const;
// Other methods:
gtsam::Rot3 rotation() const;
Rename Sphere2 -> Unit3
2014-02-23 05:20:28 +08:00
gtsam::Unit3 direction() const;
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
Matrix matrix() const;
double error(Vector vA, Vector vB);
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/Cal3_S2.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class Cal3_S2 {
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Constructors
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
Cal3_S2();
Cal3_S2(double fx, double fy, double s, double u0, double v0);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Cal3_S2(Vector v);
Cal3_S2(double fov, int w, int h);
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Testable
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
void print(string s) const;
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
bool equals(const gtsam::Cal3_S2& rhs, double tol) const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Manifold
static size_t Dim();
size_t dim() const;
gtsam::Cal3_S2 retract(Vector v) const;
Vector localCoordinates(const gtsam::Cal3_S2& c) const;
// Action on Point2
gtsam::Point2 calibrate(const gtsam::Point2& p) const;
gtsam::Point2 uncalibrate(const gtsam::Point2& p) const;
// Standard Interface
double fx() const;
double fy() const;
double skew() const;
double px() const;
double py() const;
gtsam::Point2 principalPoint() const;
Vector vector() const;
replace Cal3_S2 deprecated matrix() with K(), add Cal3DS2 support to triangulation
2020-02-05 13:44:50 +08:00
Matrix K() const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
Matrix matrix() const;
Matrix matrix_inverse() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
};
Wrapping Cal3Unified as a derived class of Cal3DS2_Base
2015-01-15 23:17:53 +08:00
#include <gtsam/geometry/Cal3DS2_Base.h>
virtual class Cal3DS2_Base {
// Standard Constructors
Cal3DS2_Base();
// Testable
void print(string s) const;
// Standard Interface
double fx() const;
double fy() const;
double skew() const;
double px() const;
double py() const;
double k1() const;
double k2() const;
wrap more functions for Cal3DS2
2018-01-23 23:16:00 +08:00
Matrix K() const;
Vector k() const;
Vector vector() const;
Wrapping Cal3Unified as a derived class of Cal3DS2_Base
2015-01-15 23:17:53 +08:00
// Action on Point2
gtsam::Point2 uncalibrate(const gtsam::Point2& p) const;
gtsam::Point2 calibrate(const gtsam::Point2& p, double tol) const;
// enabling serialization functionality
void serialize() const;
};
Simplified include handling in wrap: no more default includes, includes are not associated with a class or a namespace.
2012-07-18 02:30:02 +08:00
#include <gtsam/geometry/Cal3DS2.h>
Wrapping Cal3Unified as a derived class of Cal3DS2_Base
2015-01-15 23:17:53 +08:00
virtual class Cal3DS2 : gtsam::Cal3DS2_Base {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard Constructors
Cal3DS2();
Wrapping Cal3Unified as a derived class of Cal3DS2_Base
2015-01-15 23:17:53 +08:00
Cal3DS2(double fx, double fy, double s, double u0, double v0, double k1, double k2);
Cal3DS2(double fx, double fy, double s, double u0, double v0, double k1, double k2, double p1, double p2);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Cal3DS2(Vector v);
// Testable
bool equals(const gtsam::Cal3DS2& rhs, double tol) const;
// Manifold
size_t dim() const;
Wrapping Cal3Unified as a derived class of Cal3DS2_Base
2015-01-15 23:17:53 +08:00
static size_t Dim();
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::Cal3DS2 retract(Vector v) const;
Vector localCoordinates(const gtsam::Cal3DS2& c) const;
Wrapping Cal3Unified as a derived class of Cal3DS2_Base
2015-01-15 23:17:53 +08:00
// enabling serialization functionality
void serialize() const;
};
#include <gtsam/geometry/Cal3Unified.h>
virtual class Cal3Unified : gtsam::Cal3DS2_Base {
// Standard Constructors
Cal3Unified();
Cal3Unified(double fx, double fy, double s, double u0, double v0, double k1, double k2);
Cal3Unified(double fx, double fy, double s, double u0, double v0, double k1, double k2, double p1, double p2, double xi);
Cal3Unified(Vector v);
// Testable
bool equals(const gtsam::Cal3Unified& rhs, double tol) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard Interface
Wrapping Cal3Unified as a derived class of Cal3DS2_Base
2015-01-15 23:17:53 +08:00
double xi() const;
gtsam::Point2 spaceToNPlane(const gtsam::Point2& p) const;
gtsam::Point2 nPlaneToSpace(const gtsam::Point2& p) const;
// Manifold
size_t dim() const;
static size_t Dim();
gtsam::Cal3Unified retract(Vector v) const;
Vector localCoordinates(const gtsam::Cal3Unified& c) const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
};
Wrapping Cal3Unified as a derived class of Cal3DS2_Base
2015-01-15 23:17:53 +08:00
#include <gtsam/geometry/Cal3_S2Stereo.h>
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
class Cal3_S2Stereo {
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Constructors
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
Cal3_S2Stereo();
Cal3_S2Stereo(double fx, double fy, double s, double u0, double v0, double b);
Constructor from vector
2013-07-23 04:26:20 +08:00
Cal3_S2Stereo(Vector v);
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Testable
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
void print(string s) const;
wrapped StereoCamera
2013-07-23 23:32:38 +08:00
bool equals(const gtsam::Cal3_S2Stereo& K, double tol) const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Interface
double fx() const;
double fy() const;
double skew() const;
double px() const;
double py() const;
gtsam::Point2 principalPoint() const;
double baseline() const;
finished wrapping visualSLAM namespace
2012-06-04 10:41:14 +08:00
};
Added specializations of insert, as well as Cal3Bundler
2014-11-11 01:06:09 +08:00
#include <gtsam/geometry/Cal3Bundler.h>
class Cal3Bundler {
// Standard Constructors
Cal3Bundler();
Cal3Bundler(double fx, double k1, double k2, double u0, double v0);
// Testable
void print(string s) const;
bool equals(const gtsam::Cal3Bundler& rhs, double tol) const;
// Manifold
static size_t Dim();
size_t dim() const;
gtsam::Cal3Bundler retract(Vector v) const;
Vector localCoordinates(const gtsam::Cal3Bundler& c) const;
// Action on Point2
gtsam::Point2 calibrate(const gtsam::Point2& p, double tol) const;
gtsam::Point2 uncalibrate(const gtsam::Point2& p) const;
// Standard Interface
double fx() const;
double fy() const;
double k1() const;
double k2() const;
double u0() const;
double v0() const;
Vector vector() const;
Vector k() const;
//Matrix K() const; //FIXME: Uppercase
// enabling serialization functionality
void serialize() const;
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/CalibratedCamera.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class CalibratedCamera {
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Constructors and Named Constructors
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
CalibratedCamera();
CalibratedCamera(const gtsam::Pose3& pose);
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
CalibratedCamera(Vector v);
capitalize static functions Level and Lookat in CalibratedCamera and PinholeCamera for matlab wrapper
2012-07-16 23:24:27 +08:00
static gtsam::CalibratedCamera Level(const gtsam::Pose2& pose2, double height);
Added CalibratedCamera to gtsam.h
2012-02-06 22:05:59 +08:00
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Testable
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void print(string s) const;
bool equals(const gtsam::CalibratedCamera& camera, double tol) const;
Added CalibratedCamera to gtsam.h
2012-02-06 22:05:59 +08:00
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Manifold
static size_t Dim();
size_t dim() const;
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
gtsam::CalibratedCamera retract(Vector d) const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
Vector localCoordinates(const gtsam::CalibratedCamera& T2) const;
Added CalibratedCamera to gtsam.h
2012-02-06 22:05:59 +08:00
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Action on Point3
gtsam::Point2 project(const gtsam::Point3& point) const;
Renamed project_to_camera to PinholeBase::Project
2015-03-07 00:46:56 +08:00
static gtsam::Point2 Project(const gtsam::Point3& cameraPoint);
Added CalibratedCamera to gtsam.h
2012-02-06 22:05:59 +08:00
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
// Standard Interface
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::Pose3 pose() const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
double range(const gtsam::Point3& p) const; // TODO: Other overloaded range methods
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Wrapped and grouped lots of geometry methods
2012-06-05 04:17:24 +08:00
};
Fixed keys in planarSLAM matlab example
2012-06-03 13:25:50 +08:00
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/PinholeCamera.h>
Fixed errors in PinholeCamera wrapping and removed SimpleCamera (made it a simple typedef)
2015-05-04 09:32:28 +08:00
template<CALIBRATION>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class PinholeCamera {
wrap SimpleCamera, and support Point2 constructor from Vector
2012-06-05 13:15:56 +08:00
// Standard Constructors and Named Constructors
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
PinholeCamera();
PinholeCamera(const gtsam::Pose3& pose);
Fixed errors in PinholeCamera wrapping and removed SimpleCamera (made it a simple typedef)
2015-05-04 09:32:28 +08:00
PinholeCamera(const gtsam::Pose3& pose, const CALIBRATION& K);
static This Level(const CALIBRATION& K, const gtsam::Pose2& pose, double height);
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
static This Level(const gtsam::Pose2& pose, double height);
Fixed errors in PinholeCamera wrapping and removed SimpleCamera (made it a simple typedef)
2015-05-04 09:32:28 +08:00
static This Lookat(const gtsam::Point3& eye, const gtsam::Point3& target,
const gtsam::Point3& upVector, const CALIBRATION& K);
wrap SimpleCamera, and support Point2 constructor from Vector
2012-06-05 13:15:56 +08:00
// Testable
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void print(string s) const;
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
bool equals(const This& camera, double tol) const;
wrap SimpleCamera, and support Point2 constructor from Vector
2012-06-05 13:15:56 +08:00
// Standard Interface
Cleaned up header and wrapped most functions (why not clean up stuff and be comprehensive when you wrap a function in class Foo, all? Takes a few minutes extra, but you're right there!)
2012-06-19 07:31:57 +08:00
gtsam::Pose3 pose() const;
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
CALIBRATION calibration() const;
wrapping SimpleCamera::lookat and visualSLAM's ISAM to MATLAB
2012-06-06 17:42:27 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Manifold
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
This retract(Vector d) const;
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
Vector localCoordinates(const This& T2) const;
Cleaned up header and wrapped most functions (why not clean up stuff and be comprehensive when you wrap a function in class Foo, all? Takes a few minutes extra, but you're right there!)
2012-06-19 07:31:57 +08:00
size_t dim() const;
static size_t Dim();
// Transformations and measurement functions
Renamed project_to_camera to PinholeBase::Project
2015-03-07 00:46:56 +08:00
static gtsam::Point2 Project(const gtsam::Point3& cameraPoint);
Cleaned up header and wrapped most functions (why not clean up stuff and be comprehensive when you wrap a function in class Foo, all? Takes a few minutes extra, but you're right there!)
2012-06-19 07:31:57 +08:00
pair<gtsam::Point2,bool> projectSafe(const gtsam::Point3& pw) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::Point2 project(const gtsam::Point3& point);
gtsam::Point3 backproject(const gtsam::Point2& p, double depth) const;
Cleaned up header and wrapped most functions (why not clean up stuff and be comprehensive when you wrap a function in class Foo, all? Takes a few minutes extra, but you're right there!)
2012-06-19 07:31:57 +08:00
double range(const gtsam::Point3& point);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
double range(const gtsam::Pose3& pose);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/SimpleCamera.h>
Small fixes to make it actually work in Matlab
2015-05-21 01:30:36 +08:00
virtual class SimpleCamera {
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
// Standard Constructors and Named Constructors
Change SimpleCamera from typedef back to regular class to make wrapping+serialiation work. Had to change some templates because vector<PinholeCamera> can't be upcast to vector<SimpleCamera>
2015-05-19 02:33:27 +08:00
SimpleCamera();
SimpleCamera(const gtsam::Pose3& pose);
SimpleCamera(const gtsam::Pose3& pose, const gtsam::Cal3_S2& K);
static gtsam::SimpleCamera Level(const gtsam::Cal3_S2& K, const gtsam::Pose2& pose, double height);
static gtsam::SimpleCamera Level(const gtsam::Pose2& pose, double height);
static gtsam::SimpleCamera Lookat(const gtsam::Point3& eye, const gtsam::Point3& target,
const gtsam::Point3& upVector, const gtsam::Cal3_S2& K);
Added SimpleCamera LookAt version with default calibration
2018-10-14 23:23:44 +08:00
static gtsam::SimpleCamera Lookat(const gtsam::Point3& eye, const gtsam::Point3& target,
const gtsam::Point3& upVector);
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
// Testable
void print(string s) const;
Change SimpleCamera from typedef back to regular class to make wrapping+serialiation work. Had to change some templates because vector<PinholeCamera> can't be upcast to vector<SimpleCamera>
2015-05-19 02:33:27 +08:00
bool equals(const gtsam::SimpleCamera& camera, double tol) const;
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
// Standard Interface
gtsam::Pose3 pose() const;
Change SimpleCamera from typedef back to regular class to make wrapping+serialiation work. Had to change some templates because vector<PinholeCamera> can't be upcast to vector<SimpleCamera>
2015-05-19 02:33:27 +08:00
gtsam::Cal3_S2 calibration() const;
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
// Manifold
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
gtsam::SimpleCamera retract(Vector d) const;
Change SimpleCamera from typedef back to regular class to make wrapping+serialiation work. Had to change some templates because vector<PinholeCamera> can't be upcast to vector<SimpleCamera>
2015-05-19 02:33:27 +08:00
Vector localCoordinates(const gtsam::SimpleCamera& T2) const;
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
size_t dim() const;
static size_t Dim();
// Transformations and measurement functions
Renamed project_to_camera to PinholeBase::Project
2015-03-07 00:46:56 +08:00
static gtsam::Point2 Project(const gtsam::Point3& cameraPoint);
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
pair<gtsam::Point2,bool> projectSafe(const gtsam::Point3& pw) const;
gtsam::Point2 project(const gtsam::Point3& point);
gtsam::Point3 backproject(const gtsam::Point2& p, double depth) const;
double range(const gtsam::Point3& point);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
double range(const gtsam::Pose3& pose);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Change SimpleCamera from typedef back to regular class to make wrapping+serialiation work. Had to change some templates because vector<PinholeCamera> can't be upcast to vector<SimpleCamera>
2015-05-19 02:33:27 +08:00
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
};
Wrapped GeneralSFMFactor and added placeholders for Cal3DS2 once it has a 'calibrate' function
2012-07-24 05:27:42 +08:00
wrapped simpleCamera function to get camera from projection matrix
2020-03-10 10:57:59 +08:00
gtsam::SimpleCamera simpleCamera(const Matrix& P);
Small fixes to make it actually work in Matlab
2015-05-21 01:30:36 +08:00
// Some typedefs for common camera types
// PinholeCameraCal3_S2 is the same as SimpleCamera above
Fixed errors in PinholeCamera wrapping and removed SimpleCamera (made it a simple typedef)
2015-05-04 09:32:28 +08:00
typedef gtsam::PinholeCamera<gtsam::Cal3_S2> PinholeCameraCal3_S2;
remove some wrapping terms to fix toolbox compile
2018-06-19 13:00:20 +08:00
// due to lack of jacobians of Cal3DS2_Base::calibrate, PinholeCamera does not apply to Cal3DS2/Unified
//typedef gtsam::PinholeCamera<gtsam::Cal3DS2> PinholeCameraCal3DS2;
//typedef gtsam::PinholeCamera<gtsam::Cal3Unified> PinholeCameraCal3Unified;
//typedef gtsam::PinholeCamera<gtsam::Cal3Bundler> PinholeCameraCal3Bundler;
Fixed errors in PinholeCamera wrapping and removed SimpleCamera (made it a simple typedef)
2015-05-04 09:32:28 +08:00
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/geometry/StereoCamera.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class StereoCamera {
wrapped StereoCamera
2013-07-23 23:32:38 +08:00
// Standard Constructors and Named Constructors
StereoCamera();
StereoCamera(const gtsam::Pose3& pose, const gtsam::Cal3_S2Stereo* K);
// Testable
void print(string s) const;
bool equals(const gtsam::StereoCamera& camera, double tol) const;
// Standard Interface
gtsam::Pose3 pose() const;
double baseline() const;
fix examples and wrapper
2015-07-29 03:14:39 +08:00
gtsam::Cal3_S2Stereo calibration() const;
wrapped StereoCamera
2013-07-23 23:32:38 +08:00
// Manifold
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
gtsam::StereoCamera retract(Vector d) const;
wrapped StereoCamera
2013-07-23 23:32:38 +08:00
Vector localCoordinates(const gtsam::StereoCamera& T2) const;
size_t dim() const;
static size_t Dim();
// Transformations and measurement functions
gtsam::StereoPoint2 project(const gtsam::Point3& point);
gtsam::Point3 backproject(const gtsam::StereoPoint2& p) const;
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
wrapped StereoCamera
2013-07-23 23:32:38 +08:00
};
Added triangulation wrapping, tested and works in MATLAB !
2015-05-04 09:54:17 +08:00
#include <gtsam/geometry/triangulation.h>
// Templates appear not yet supported for free functions
gtsam::Point3 triangulatePoint3(const gtsam::Pose3Vector& poses,
gtsam::Cal3_S2* sharedCal, const gtsam::Point2Vector& measurements,
double rank_tol, bool optimize);
replace Cal3_S2 deprecated matrix() with K(), add Cal3DS2 support to triangulation
2020-02-05 13:44:50 +08:00
gtsam::Point3 triangulatePoint3(const gtsam::Pose3Vector& poses,
gtsam::Cal3DS2* sharedCal, const gtsam::Point2Vector& measurements,
double rank_tol, bool optimize);
Added triangulation wrapping, tested and works in MATLAB !
2015-05-04 09:54:17 +08:00
gtsam::Point3 triangulatePoint3(const gtsam::Pose3Vector& poses,
gtsam::Cal3Bundler* sharedCal, const gtsam::Point2Vector& measurements,
double rank_tol, bool optimize);
Additional Kalman filter constructor takes covariance
2012-01-18 04:04:37 +08:00
//*************************************************************************
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
// Symbolic
Additional Kalman filter constructor takes covariance
2012-01-18 04:04:37 +08:00
//*************************************************************************
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/symbolic/SymbolicFactor.h>
virtual class SymbolicFactor {
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
// Standard Constructors and Named Constructors
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
SymbolicFactor(const gtsam::SymbolicFactor& f);
SymbolicFactor();
SymbolicFactor(size_t j);
SymbolicFactor(size_t j1, size_t j2);
SymbolicFactor(size_t j1, size_t j2, size_t j3);
SymbolicFactor(size_t j1, size_t j2, size_t j3, size_t j4);
SymbolicFactor(size_t j1, size_t j2, size_t j3, size_t j4, size_t j5);
SymbolicFactor(size_t j1, size_t j2, size_t j3, size_t j4, size_t j5, size_t j6);
static gtsam::SymbolicFactor FromKeys(const gtsam::KeyVector& js);
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
// From Factor
size_t size() const;
void print(string s) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
bool equals(const gtsam::SymbolicFactor& other, double tol) const;
gtsam::KeyVector keys();
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
};
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/symbolic/SymbolicFactorGraph.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
virtual class SymbolicFactorGraph {
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
SymbolicFactorGraph();
SymbolicFactorGraph(const gtsam::SymbolicBayesNet& bayesNet);
SymbolicFactorGraph(const gtsam::SymbolicBayesTree& bayesTree);
// From FactorGraph
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
void push_back(gtsam::SymbolicFactor* factor);
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
void print(string s) const;
bool equals(const gtsam::SymbolicFactorGraph& rhs, double tol) const;
size_t size() const;
Added exists() as a utility for matlab to check whether a pointer is live
2013-08-24 04:06:08 +08:00
bool exists(size_t idx) const;
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
// Standard interface
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::KeySet keys() const;
void push_back(const gtsam::SymbolicFactorGraph& graph);
void push_back(const gtsam::SymbolicBayesNet& bayesNet);
void push_back(const gtsam::SymbolicBayesTree& bayesTree);
Added eliminateFrontals function to FactorGraph, SymbolicFactorGraph, and GaussianFactorGraph - eliminates requested number of frontal variables and returns the resulting conditional and remaining factor graph
2012-08-31 03:58:33 +08:00
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
//Advanced Interface
void push_factor(size_t key);
void push_factor(size_t key1, size_t key2);
void push_factor(size_t key1, size_t key2, size_t key3);
void push_factor(size_t key1, size_t key2, size_t key3, size_t key4);
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::SymbolicBayesNet* eliminateSequential();
gtsam::SymbolicBayesNet* eliminateSequential(const gtsam::Ordering& ordering);
gtsam::SymbolicBayesTree* eliminateMultifrontal();
gtsam::SymbolicBayesTree* eliminateMultifrontal(const gtsam::Ordering& ordering);
pair<gtsam::SymbolicBayesNet*, gtsam::SymbolicFactorGraph*> eliminatePartialSequential(
const gtsam::Ordering& ordering);
pair<gtsam::SymbolicBayesNet*, gtsam::SymbolicFactorGraph*> eliminatePartialSequential(
const gtsam::KeyVector& keys);
pair<gtsam::SymbolicBayesTree*, gtsam::SymbolicFactorGraph*> eliminatePartialMultifrontal(
const gtsam::Ordering& ordering);
pair<gtsam::SymbolicBayesTree*, gtsam::SymbolicFactorGraph*> eliminatePartialMultifrontal(
const gtsam::KeyVector& keys);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
gtsam::SymbolicBayesNet* marginalMultifrontalBayesNet(const gtsam::Ordering& ordering);
gtsam::SymbolicBayesNet* marginalMultifrontalBayesNet(const gtsam::KeyVector& key_vector);
gtsam::SymbolicBayesNet* marginalMultifrontalBayesNet(const gtsam::Ordering& ordering,
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
const gtsam::Ordering& marginalizedVariableOrdering);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
gtsam::SymbolicBayesNet* marginalMultifrontalBayesNet(const gtsam::KeyVector& key_vector,
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
const gtsam::Ordering& marginalizedVariableOrdering);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
gtsam::SymbolicFactorGraph* marginal(const gtsam::KeyVector& key_vector);
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
};
#include <gtsam/symbolic/SymbolicConditional.h>
virtual class SymbolicConditional : gtsam::SymbolicFactor {
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
// Standard Constructors and Named Constructors
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
SymbolicConditional();
SymbolicConditional(const gtsam::SymbolicConditional& other);
SymbolicConditional(size_t key);
SymbolicConditional(size_t key, size_t parent);
SymbolicConditional(size_t key, size_t parent1, size_t parent2);
SymbolicConditional(size_t key, size_t parent1, size_t parent2, size_t parent3);
static gtsam::SymbolicConditional FromKeys(const gtsam::KeyVector& keys, size_t nrFrontals);
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
// Testable
void print(string s) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
bool equals(const gtsam::SymbolicConditional& other, double tol) const;
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
// Standard interface
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
size_t nrFrontals() const;
size_t nrParents() const;
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
};
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/symbolic/SymbolicBayesNet.h>
class SymbolicBayesNet {
SymbolicBayesNet();
SymbolicBayesNet(const gtsam::SymbolicBayesNet& other);
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
// Testable
void print(string s) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
bool equals(const gtsam::SymbolicBayesNet& other, double tol) const;
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
// Standard interface
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
size_t size() const;
void saveGraph(string s) const;
add KeyGroupMap to wrap ISAM2 update with group ordering to matlab. Wrap at() in SymbolicBayesNet, and GaussianConditional constructors with no noise model.
2013-12-04 22:36:13 +08:00
gtsam::SymbolicConditional* at(size_t idx) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::SymbolicConditional* front() const;
gtsam::SymbolicConditional* back() const;
void push_back(gtsam::SymbolicConditional* conditional);
void push_back(const gtsam::SymbolicBayesNet& bayesNet);
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
};
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/symbolic/SymbolicBayesTree.h>
class SymbolicBayesTree {
//Constructors
SymbolicBayesTree();
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
SymbolicBayesTree(const gtsam::SymbolicBayesTree& other);
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
// Testable
void print(string s);
bool equals(const gtsam::SymbolicBayesTree& other, double tol) const;
//Standard Interface
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
//size_t findParentClique(const gtsam::IndexVector& parents) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
size_t size();
void saveGraph(string s) const;
void clear();
void deleteCachedShortcuts();
size_t numCachedSeparatorMarginals() const;
Deprecated some more methods
2016-02-09 07:16:11 +08:00
tabs converted to two spaces
2013-10-11 01:52:57 +08:00
gtsam::SymbolicConditional* marginalFactor(size_t key) const;
gtsam::SymbolicFactorGraph* joint(size_t key1, size_t key2) const;
gtsam::SymbolicBayesNet* jointBayesNet(size_t key1, size_t key2) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
};
// class SymbolicBayesTreeClique {
// BayesTreeClique();
// BayesTreeClique(CONDITIONAL* conditional);
static function & method for axis-angle with improved tests and fix for sign ambiguity
2020-03-09 05:07:40 +08:00
// // BayesTreeClique(const pair<typename ConditionalType::shared_ptr, typename ConditionalType::FactorType::shared_ptr>& result) : Base(result) {}
Deprecated some more methods
2016-02-09 07:16:11 +08:00
//
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
// bool equals(const This& other, double tol) const;
// void print(string s) const;
// void printTree() const; // Default indent of ""
// void printTree(string indent) const;
// size_t numCachedSeparatorMarginals() const;
Deprecated some more methods
2016-02-09 07:16:11 +08:00
//
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
// CONDITIONAL* conditional() const;
// bool isRoot() const;
// size_t treeSize() const;
// // const std::list<derived_ptr>& children() const { return children_; }
// // derived_ptr parent() const { return parent_.lock(); }
Deprecated some more methods
2016-02-09 07:16:11 +08:00
//
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
// // FIXME: need wrapped versions graphs, BayesNet
// // BayesNet<ConditionalType> shortcut(derived_ptr root, Eliminate function) const;
// // FactorGraph<FactorType> marginal(derived_ptr root, Eliminate function) const;
// // FactorGraph<FactorType> joint(derived_ptr C2, derived_ptr root, Eliminate function) const;
add KeyGroupMap to wrap ISAM2 update with group ordering to matlab. Wrap at() in SymbolicBayesNet, and GaussianConditional constructors with no noise model.
2013-12-04 22:36:13 +08:00
//
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
// void deleteCachedShortcuts();
// };
#include <gtsam/inference/VariableIndex.h>
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
class VariableIndex {
// Standard Constructors and Named Constructors
VariableIndex();
Wrapped additional function
2012-09-10 22:39:36 +08:00
// TODO: Templetize constructor when wrap supports it
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
//template<T = {gtsam::FactorGraph}>
//VariableIndex(const T& factorGraph, size_t nVariables);
//VariableIndex(const T& factorGraph);
Constructor overloads are supported, but arguments *have* to have different names
2017-08-07 05:57:40 +08:00
VariableIndex(const gtsam::SymbolicFactorGraph& sfg);
VariableIndex(const gtsam::GaussianFactorGraph& gfg);
VariableIndex(const gtsam::NonlinearFactorGraph& fg);
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
VariableIndex(const gtsam::VariableIndex& other);
// Testable
bool equals(const gtsam::VariableIndex& other, double tol) const;
void print(string s) const;
// Standard interface
size_t size() const;
size_t nFactors() const;
size_t nEntries() const;
};
Fixed keys in planarSLAM matlab example
2012-06-03 13:25:50 +08:00
Additional Kalman filter constructor takes covariance
2012-01-18 04:04:37 +08:00
//*************************************************************************
// linear
//*************************************************************************
wrap noiseModel classes. Inheritance works nicely in Matlab. Probably we don't need shared noise model classes anymore.
2012-06-19 14:08:55 +08:00
namespace noiseModel {
More flexible handling of includes in wrap - can now use multiple includes both at the namespace and class levels, and namespace includes do not override the default class-name includes of their enclosed classes.
2012-07-17 23:51:35 +08:00
#include <gtsam/linear/NoiseModel.h>
Added a check that all wrapped classes involved in a heirarchy are marked virtual
2012-07-11 06:38:21 +08:00
virtual class Base {
Added print in base class so all derived have it. Added comment how wrap currently does not handle Base class correctly in case of name clash, apparently.
2019-03-15 12:25:52 +08:00
void print(string s) const;
Type for Factor indices, dual to "Key" This avoids a couple of confusing uses of KeySet to refer to lists of Factors, and makes code more readable where formerly using size_t to index factors.
2019-02-27 15:50:50 +08:00
// Methods below are available for all noise models. However, can't add them
Added print in base class so all derived have it. Added comment how wrap currently does not handle Base class correctly in case of name clash, apparently.
2019-03-15 12:25:52 +08:00
// because wrap (incorrectly) thinks robust classes derive from this Base as well.
// bool isConstrained() const;
// bool isUnit() const;
// size_t dim() const;
// Vector sigmas() const;
clean up noise model: Remove Shared[NoiseModel] classes and headers, typedef for backward compatibility in NoiseModel.h. Fix all tests and examples to create shared noise models through static functions in noise model classes. Fix MATLAB wrapper and examples as well. Add tests for MATLAB examples
2012-06-23 03:36:49 +08:00
};
Added a check that all wrapped classes involved in a heirarchy are marked virtual
2012-07-11 06:38:21 +08:00
virtual class Gaussian : gtsam::noiseModel::Base {
add Information constructor to python wrapper for gaussian noise model
2020-01-15 07:00:30 +08:00
static gtsam::noiseModel::Gaussian* Information(Matrix R);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::noiseModel::Gaussian* SqrtInformation(Matrix R);
static gtsam::noiseModel::Gaussian* Covariance(Matrix R);
Wrapped more useful noiseModel methods
2019-03-19 11:15:53 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
bool equals(gtsam::noiseModel::Base& expected, double tol);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
Wrapped more useful noiseModel methods
2019-03-19 11:15:53 +08:00
// access to noise model
Matrix R() const;
Matrix information() const;
Matrix covariance() const;
// Whitening operations
Vector whiten(Vector v) const;
Vector unwhiten(Vector v) const;
Matrix Whiten(Matrix H) const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
unbroke a number of classes in linear, testing them with gtsam_experimental/matlab code
2011-10-21 13:07:35 +08:00
};
Added a check that all wrapped classes involved in a heirarchy are marked virtual
2012-07-11 06:38:21 +08:00
virtual class Diagonal : gtsam::noiseModel::Gaussian {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::noiseModel::Diagonal* Sigmas(Vector sigmas);
static gtsam::noiseModel::Diagonal* Variances(Vector variances);
static gtsam::noiseModel::Diagonal* Precisions(Vector precisions);
Enabled R matrix in noise model.
2013-06-14 05:17:21 +08:00
Matrix R() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
Wrapped more useful noiseModel methods
2019-03-19 11:15:53 +08:00
// access to noise model
Vector sigmas() const;
Vector invsigmas() const;
Vector precisions() const;
Type for Factor indices, dual to "Key" This avoids a couple of confusing uses of KeySet to refer to lists of Factors, and makes code more readable where formerly using size_t to index factors.
2019-02-27 15:50:50 +08:00
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
wrap noiseModel classes. Inheritance works nicely in Matlab. Probably we don't need shared noise model classes anymore.
2012-06-19 14:08:55 +08:00
};
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
virtual class Constrained : gtsam::noiseModel::Diagonal {
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
static gtsam::noiseModel::Constrained* MixedSigmas(Vector mu, Vector sigmas);
static gtsam::noiseModel::Constrained* MixedSigmas(double m, Vector sigmas);
static gtsam::noiseModel::Constrained* MixedVariances(Vector mu, Vector variances);
static gtsam::noiseModel::Constrained* MixedVariances(Vector variances);
static gtsam::noiseModel::Constrained* MixedPrecisions(Vector mu, Vector precisions);
static gtsam::noiseModel::Constrained* MixedPrecisions(Vector precisions);
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
static gtsam::noiseModel::Constrained* All(size_t dim);
Comments and argument name only change
2013-04-11 03:35:48 +08:00
static gtsam::noiseModel::Constrained* All(size_t dim, double mu);
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
gtsam::noiseModel::Constrained* unit() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
};
Wrapped additional functions in factors and factor graphs, added factor heirarchy, fixed mistake in noisemodel heirarchy
2012-07-12 02:18:57 +08:00
virtual class Isotropic : gtsam::noiseModel::Diagonal {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::noiseModel::Isotropic* Sigma(size_t dim, double sigma);
static gtsam::noiseModel::Isotropic* Variance(size_t dim, double varianace);
static gtsam::noiseModel::Isotropic* Precision(size_t dim, double precision);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
Wrapped more useful noiseModel methods
2019-03-19 11:15:53 +08:00
// access to noise model
double sigma() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
unbroke a number of classes in linear, testing them with gtsam_experimental/matlab code
2011-10-21 13:07:35 +08:00
};
Wrapped additional functions in factors and factor graphs, added factor heirarchy, fixed mistake in noisemodel heirarchy
2012-07-12 02:18:57 +08:00
virtual class Unit : gtsam::noiseModel::Isotropic {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
static gtsam::noiseModel::Unit* Create(size_t dim);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
wrap noiseModel classes. Inheritance works nicely in Matlab. Probably we don't need shared noise model classes anymore.
2012-06-19 14:08:55 +08:00
};
change namespace "MEstimator" to "mEstimator" to wrap robust noise models to matlab. Add Tukey.
2013-02-08 03:19:33 +08:00
namespace mEstimator {
virtual class Base {
Added print in base class so all derived have it. Added comment how wrap currently does not handle Base class correctly in case of name clash, apparently.
2019-03-15 12:25:52 +08:00
void print(string s) const;
change namespace "MEstimator" to "mEstimator" to wrap robust noise models to matlab. Add Tukey.
2013-02-08 03:19:33 +08:00
};
virtual class Null: gtsam::noiseModel::mEstimator::Base {
Null();
static gtsam::noiseModel::mEstimator::Null* Create();
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
wrapped more mEstimators as well as their weight functions
2019-09-19 06:44:21 +08:00
double weight(double error) const;
implemented residual functions for common M-estimators and added corresponding tests
2019-10-02 16:04:34 +08:00
double residual(double error) const;
change namespace "MEstimator" to "mEstimator" to wrap robust noise models to matlab. Add Tukey.
2013-02-08 03:19:33 +08:00
};
virtual class Fair: gtsam::noiseModel::mEstimator::Base {
Fair(double c);
static gtsam::noiseModel::mEstimator::Fair* Create(double c);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
wrapped more mEstimators as well as their weight functions
2019-09-19 06:44:21 +08:00
double weight(double error) const;
add residual function for Fair mEstimator wrapper
2019-10-10 03:46:24 +08:00
double residual(double error) const;
change namespace "MEstimator" to "mEstimator" to wrap robust noise models to matlab. Add Tukey.
2013-02-08 03:19:33 +08:00
};
virtual class Huber: gtsam::noiseModel::mEstimator::Base {
Huber(double k);
static gtsam::noiseModel::mEstimator::Huber* Create(double k);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
wrapped more mEstimators as well as their weight functions
2019-09-19 06:44:21 +08:00
double weight(double error) const;
implemented residual functions for common M-estimators and added corresponding tests
2019-10-02 16:04:34 +08:00
double residual(double error) const;
wrapped more mEstimators as well as their weight functions
2019-09-19 06:44:21 +08:00
};
virtual class Cauchy: gtsam::noiseModel::mEstimator::Base {
Cauchy(double k);
static gtsam::noiseModel::mEstimator::Cauchy* Create(double k);
// enabling serialization functionality
void serializable() const;
double weight(double error) const;
implemented residual functions for common M-estimators and added corresponding tests
2019-10-02 16:04:34 +08:00
double residual(double error) const;
change namespace "MEstimator" to "mEstimator" to wrap robust noise models to matlab. Add Tukey.
2013-02-08 03:19:33 +08:00
};
virtual class Tukey: gtsam::noiseModel::mEstimator::Base {
Tukey(double k);
static gtsam::noiseModel::mEstimator::Tukey* Create(double k);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
wrapped more mEstimators as well as their weight functions
2019-09-19 06:44:21 +08:00
double weight(double error) const;
implemented residual functions for common M-estimators and added corresponding tests
2019-10-02 16:04:34 +08:00
double residual(double error) const;
change namespace "MEstimator" to "mEstimator" to wrap robust noise models to matlab. Add Tukey.
2013-02-08 03:19:33 +08:00
};
Added Welsch model to gtsam.h
2019-08-29 23:15:00 +08:00
virtual class Welsch: gtsam::noiseModel::mEstimator::Base {
Welsch(double k);
static gtsam::noiseModel::mEstimator::Welsch* Create(double k);
// enabling serialization functionality
void serializable() const;
wrapped more mEstimators as well as their weight functions
2019-09-19 06:44:21 +08:00
double weight(double error) const;
implemented residual functions for common M-estimators and added corresponding tests
2019-10-02 16:04:34 +08:00
double residual(double error) const;
Added Welsch model to gtsam.h
2019-08-29 23:15:00 +08:00
};
wrapped more mEstimators as well as their weight functions
2019-09-19 06:44:21 +08:00
virtual class GemanMcClure: gtsam::noiseModel::mEstimator::Base {
formatting; removed virtual from derived classes; added default values for L2WithDeadZone constructor to allow serialization
2019-10-10 03:33:40 +08:00
GemanMcClure(double c);
static gtsam::noiseModel::mEstimator::GemanMcClure* Create(double c);
wrapped more mEstimators as well as their weight functions
2019-09-19 06:44:21 +08:00
// enabling serialization functionality
void serializable() const;
double weight(double error) const;
implemented residual functions for common M-estimators and added corresponding tests
2019-10-02 16:04:34 +08:00
double residual(double error) const;
Added Welsch model to gtsam.h
2019-08-29 23:15:00 +08:00
};
wrap DCS and L2WithDeadZone estimators
2019-10-09 09:26:11 +08:00
virtual class DCS: gtsam::noiseModel::mEstimator::Base {
DCS(double c);
static gtsam::noiseModel::mEstimator::DCS* Create(double c);
// enabling serialization functionality
void serializable() const;
double weight(double error) const;
double residual(double error) const;
Added Welsch model to gtsam.h
2019-08-29 23:15:00 +08:00
};
wrap DCS and L2WithDeadZone estimators
2019-10-09 09:26:11 +08:00
virtual class L2WithDeadZone: gtsam::noiseModel::mEstimator::Base {
L2WithDeadZone(double k);
static gtsam::noiseModel::mEstimator::L2WithDeadZone* Create(double k);
// enabling serialization functionality
void serializable() const;
double weight(double error) const;
double residual(double error) const;
};
Added Welsch model to gtsam.h
2019-08-29 23:15:00 +08:00
change namespace "MEstimator" to "mEstimator" to wrap robust noise models to matlab. Add Tukey.
2013-02-08 03:19:33 +08:00
}///\namespace mEstimator
virtual class Robust : gtsam::noiseModel::Base {
Robust(const gtsam::noiseModel::mEstimator::Base* robust, const gtsam::noiseModel::Base* noise);
static gtsam::noiseModel::Robust* Create(const gtsam::noiseModel::mEstimator::Base* robust, const gtsam::noiseModel::Base* noise);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
void serializable() const;
change namespace "MEstimator" to "mEstimator" to wrap robust noise models to matlab. Add Tukey.
2013-02-08 03:19:33 +08:00
};
wrap noiseModel classes. Inheritance works nicely in Matlab. Probably we don't need shared noise model classes anymore.
2012-06-19 14:08:55 +08:00
}///\namespace noiseModel
Simplified include handling in wrap: no more default includes, includes are not associated with a class or a namespace.
2012-07-18 02:30:02 +08:00
#include <gtsam/linear/Sampler.h>
Removed sample() functions and global random number generator
2012-06-23 00:38:01 +08:00
class Sampler {
Fixed issues with deprecated Sampler methods
2020-04-05 01:57:05 +08:00
// Constructors
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Sampler(gtsam::noiseModel::Diagonal* model, int seed);
Sampler(Vector sigmas, int seed);
Removed sample() functions and global random number generator
2012-06-23 00:38:01 +08:00
Fixed issues with deprecated Sampler methods
2020-04-05 01:57:05 +08:00
// Standard Interface
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
size_t dim() const;
Vector sigmas() const;
gtsam::noiseModel::Diagonal* model() const;
Vector sample();
wrap noiseModel classes. Inheritance works nicely in Matlab. Probably we don't need shared noise model classes anymore.
2012-06-19 14:08:55 +08:00
};
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/linear/VectorValues.h>
unbroke a number of classes in linear, testing them with gtsam_experimental/matlab code
2011-10-21 13:07:35 +08:00
class VectorValues {
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
//Constructors
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
VectorValues();
VectorValues(const gtsam::VectorValues& other);
//Named Constructors
static gtsam::VectorValues Zero(const gtsam::VectorValues& model);
//Standard Interface
size_t size() const;
size_t dim(size_t j) const;
bool exists(size_t j) const;
void print(string s) const;
bool equals(const gtsam::VectorValues& expected, double tol) const;
void insert(size_t j, Vector value);
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
Vector vector() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Vector at(size_t j) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
void update(const gtsam::VectorValues& values);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
//Advanced Interface
void setZero();
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
Added scale() and add() for VectorValues with a matlab interface
2013-02-24 04:31:42 +08:00
gtsam::VectorValues add(const gtsam::VectorValues& c) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
void addInPlace(const gtsam::VectorValues& c);
gtsam::VectorValues subtract(const gtsam::VectorValues& c) const;
gtsam::VectorValues scale(double a) const;
void scaleInPlace(double a);
unbroke a number of classes in linear, testing them with gtsam_experimental/matlab code
2011-10-21 13:07:35 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
bool hasSameStructure(const gtsam::VectorValues& other) const;
double dot(const gtsam::VectorValues& V) const;
double norm() const;
double squaredNorm() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Re-instaed deleted classes
2011-10-23 03:42:02 +08:00
};
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/linear/GaussianFactor.h>
Wrapped additional functions in factors and factor graphs, added factor heirarchy, fixed mistake in noisemodel heirarchy
2012-07-12 02:18:57 +08:00
virtual class GaussianFactor {
wrap keys for GaussianFactor
2014-10-19 12:35:18 +08:00
gtsam::KeyVector keys() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void print(string s) const;
bool equals(const gtsam::GaussianFactor& lf, double tol) const;
double error(const gtsam::VectorValues& c) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::GaussianFactor* clone() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::GaussianFactor* negate() const;
Cleaned up information/augmentedInformation for GaussianFactor and GaussianConditional
2012-10-09 06:40:37 +08:00
Matrix augmentedInformation() const;
Matrix information() const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
Matrix augmentedJacobian() const;
pair<Matrix, Vector> jacobian() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
size_t size() const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
bool empty() const;
Re-instaed deleted classes
2011-10-23 03:42:02 +08:00
};
unbroke a number of classes in linear, testing them with gtsam_experimental/matlab code
2011-10-21 13:07:35 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/linear/JacobianFactor.h>
Wrapped additional functions in factors and factor graphs, added factor heirarchy, fixed mistake in noisemodel heirarchy
2012-07-12 02:18:57 +08:00
virtual class JacobianFactor : gtsam::GaussianFactor {
Wrapped combine constructors for JacobianFactor and HessianFactor
2013-10-09 05:43:14 +08:00
//Constructors
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
JacobianFactor();
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
JacobianFactor(const gtsam::GaussianFactor& factor);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
JacobianFactor(Vector b_in);
JacobianFactor(size_t i1, Matrix A1, Vector b,
const gtsam::noiseModel::Diagonal* model);
JacobianFactor(size_t i1, Matrix A1, size_t i2, Matrix A2, Vector b,
const gtsam::noiseModel::Diagonal* model);
JacobianFactor(size_t i1, Matrix A1, size_t i2, Matrix A2, size_t i3, Matrix A3,
Vector b, const gtsam::noiseModel::Diagonal* model);
Wrapped combine constructors for JacobianFactor and HessianFactor
2013-10-09 05:43:14 +08:00
JacobianFactor(const gtsam::GaussianFactorGraph& graph);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
//Testable
void print(string s) const;
void printKeys(string s) const;
bool equals(const gtsam::GaussianFactor& lf, double tol) const;
size_t size() const;
Vector unweighted_error(const gtsam::VectorValues& c) const;
Vector error_vector(const gtsam::VectorValues& c) const;
double error(const gtsam::VectorValues& c) const;
//Standard Interface
Cleaned up information/augmentedInformation for GaussianFactor and GaussianConditional
2012-10-09 06:40:37 +08:00
Matrix getA() const;
Vector getb() const;
size_t rows() const;
size_t cols() const;
bool isConstrained() const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
pair<Matrix, Vector> jacobianUnweighted() const;
Matrix augmentedJacobianUnweighted() const;
Cleaned up information/augmentedInformation for GaussianFactor and GaussianConditional
2012-10-09 06:40:37 +08:00
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
void transposeMultiplyAdd(double alpha, Vector e, gtsam::VectorValues& x) const;
Cleaned up information/augmentedInformation for GaussianFactor and GaussianConditional
2012-10-09 06:40:37 +08:00
gtsam::JacobianFactor whiten() const;
Deprecated some more methods
2016-02-09 07:16:11 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
pair<gtsam::GaussianConditional*, gtsam::JacobianFactor*> eliminate(const gtsam::Ordering& keys) const;
Cleaned up information/augmentedInformation for GaussianFactor and GaussianConditional
2012-10-09 06:40:37 +08:00
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
void setModel(bool anyConstrained, Vector sigmas);
Cleaned up information/augmentedInformation for GaussianFactor and GaussianConditional
2012-10-09 06:40:37 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::noiseModel::Diagonal* get_model() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Re-instaed deleted classes
2011-10-23 03:42:02 +08:00
};
unbroke a number of classes in linear, testing them with gtsam_experimental/matlab code
2011-10-21 13:07:35 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/linear/HessianFactor.h>
Wrapped additional functions in factors and factor graphs, added factor heirarchy, fixed mistake in noisemodel heirarchy
2012-07-12 02:18:57 +08:00
virtual class HessianFactor : gtsam::GaussianFactor {
Wrapped combine constructors for JacobianFactor and HessianFactor
2013-10-09 05:43:14 +08:00
//Constructors
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
HessianFactor();
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
HessianFactor(const gtsam::GaussianFactor& factor);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
HessianFactor(size_t j, Matrix G, Vector g, double f);
HessianFactor(size_t j, Vector mu, Matrix Sigma);
HessianFactor(size_t j1, size_t j2, Matrix G11, Matrix G12, Vector g1, Matrix G22,
Vector g2, double f);
HessianFactor(size_t j1, size_t j2, size_t j3, Matrix G11, Matrix G12, Matrix G13,
Vector g1, Matrix G22, Matrix G23, Vector g2, Matrix G33, Vector g3,
double f);
Wrapped combine constructors for JacobianFactor and HessianFactor
2013-10-09 05:43:14 +08:00
HessianFactor(const gtsam::GaussianFactorGraph& factors);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
//Testable
size_t size() const;
void print(string s) const;
void printKeys(string s) const;
bool equals(const gtsam::GaussianFactor& lf, double tol) const;
double error(const gtsam::VectorValues& c) const;
//Standard Interface
size_t rows() const;
Attempt at fixing matlab wrapper issues
2016-06-20 16:11:57 +08:00
Matrix information() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
double constantTerm() const;
Vector linearTerm() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
[with Vadim] wrapped HessianFactor and added a bunch of "add" methods to GaussianFactorGraph. Unfortunately, because overloading is not supported, only the last add works (by design, because we needed it, the HessianFactor add).
2012-01-20 12:35:12 +08:00
};
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/linear/GaussianFactorGraph.h>
Re-instaed deleted classes
2011-10-23 03:42:02 +08:00
class GaussianFactorGraph {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
GaussianFactorGraph();
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
GaussianFactorGraph(const gtsam::GaussianBayesNet& bayesNet);
GaussianFactorGraph(const gtsam::GaussianBayesTree& bayesTree);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// From FactorGraph
void print(string s) const;
bool equals(const gtsam::GaussianFactorGraph& lfgraph, double tol) const;
size_t size() const;
gtsam::GaussianFactor* at(size_t idx) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::KeySet keys() const;
wrap more functions
2017-05-16 02:42:45 +08:00
gtsam::KeyVector keyVector() const;
Added exists() as a utility for matlab to check whether a pointer is live
2013-08-24 04:06:08 +08:00
bool exists(size_t idx) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Building the graph
Exposed more interfaces for working with linear graphs and bayes nets
2013-10-31 05:34:52 +08:00
void push_back(const gtsam::GaussianFactor* factor);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
void push_back(const gtsam::GaussianConditional* conditional);
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
void push_back(const gtsam::GaussianFactorGraph& graph);
void push_back(const gtsam::GaussianBayesNet& bayesNet);
void push_back(const gtsam::GaussianBayesTree& bayesTree);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void add(const gtsam::GaussianFactor& factor);
void add(Vector b);
void add(size_t key1, Matrix A1, Vector b, const gtsam::noiseModel::Diagonal* model);
void add(size_t key1, Matrix A1, size_t key2, Matrix A2, Vector b,
const gtsam::noiseModel::Diagonal* model);
void add(size_t key1, Matrix A1, size_t key2, Matrix A2, size_t key3, Matrix A3,
Vector b, const gtsam::noiseModel::Diagonal* model);
[with Vadim] wrapped HessianFactor and added a bunch of "add" methods to GaussianFactorGraph. Unfortunately, because overloading is not supported, only the last add works (by design, because we needed it, the HessianFactor add).
2012-01-20 12:35:12 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// error and probability
double error(const gtsam::VectorValues& c) const;
double probPrime(const gtsam::VectorValues& c) const;
[with Vadim] wrapped HessianFactor and added a bunch of "add" methods to GaussianFactorGraph. Unfortunately, because overloading is not supported, only the last add works (by design, because we needed it, the HessianFactor add).
2012-01-20 12:35:12 +08:00
Added negate() and clone() to GaussianFactorGraph
2013-11-07 23:29:38 +08:00
gtsam::GaussianFactorGraph clone() const;
gtsam::GaussianFactorGraph negate() const;
Deprecated some more methods
2016-02-09 07:16:11 +08:00
// Optimizing and linear algebra
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::VectorValues optimize() const;
gtsam::VectorValues optimize(const gtsam::Ordering& ordering) const;
gtsam::VectorValues optimizeGradientSearch() const;
gtsam::VectorValues gradient(const gtsam::VectorValues& x0) const;
gtsam::VectorValues gradientAtZero() const;
[with Vadim] wrapped HessianFactor and added a bunch of "add" methods to GaussianFactorGraph. Unfortunately, because overloading is not supported, only the last add works (by design, because we needed it, the HessianFactor add).
2012-01-20 12:35:12 +08:00
Added missing MATLAB wrapping of GaussianFactorGraph elimination functions
2013-09-19 01:23:33 +08:00
// Elimination and marginals
gtsam::GaussianBayesNet* eliminateSequential();
gtsam::GaussianBayesNet* eliminateSequential(const gtsam::Ordering& ordering);
gtsam::GaussianBayesTree* eliminateMultifrontal();
gtsam::GaussianBayesTree* eliminateMultifrontal(const gtsam::Ordering& ordering);
pair<gtsam::GaussianBayesNet*, gtsam::GaussianFactorGraph*> eliminatePartialSequential(
const gtsam::Ordering& ordering);
pair<gtsam::GaussianBayesNet*, gtsam::GaussianFactorGraph*> eliminatePartialSequential(
const gtsam::KeyVector& keys);
pair<gtsam::GaussianBayesTree*, gtsam::GaussianFactorGraph*> eliminatePartialMultifrontal(
const gtsam::Ordering& ordering);
pair<gtsam::GaussianBayesTree*, gtsam::GaussianFactorGraph*> eliminatePartialMultifrontal(
const gtsam::KeyVector& keys);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
gtsam::GaussianBayesNet* marginalMultifrontalBayesNet(const gtsam::Ordering& ordering);
gtsam::GaussianBayesNet* marginalMultifrontalBayesNet(const gtsam::KeyVector& key_vector);
gtsam::GaussianBayesNet* marginalMultifrontalBayesNet(const gtsam::Ordering& ordering,
Added missing MATLAB wrapping of GaussianFactorGraph elimination functions
2013-09-19 01:23:33 +08:00
const gtsam::Ordering& marginalizedVariableOrdering);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
gtsam::GaussianBayesNet* marginalMultifrontalBayesNet(const gtsam::KeyVector& key_vector,
Added missing MATLAB wrapping of GaussianFactorGraph elimination functions
2013-09-19 01:23:33 +08:00
const gtsam::Ordering& marginalizedVariableOrdering);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
gtsam::GaussianFactorGraph* marginal(const gtsam::KeyVector& key_vector);
Added missing MATLAB wrapping of GaussianFactorGraph elimination functions
2013-09-19 01:23:33 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Conversion to matrices
Matrix sparseJacobian_() const;
Matrix augmentedJacobian() const;
Added matlab interfaces to GaussianFactorGraph to use ordered dense hessians/jacobians
2013-10-30 23:54:03 +08:00
Matrix augmentedJacobian(const gtsam::Ordering& ordering) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
pair<Matrix,Vector> jacobian() const;
Added matlab interfaces to GaussianFactorGraph to use ordered dense hessians/jacobians
2013-10-30 23:54:03 +08:00
pair<Matrix,Vector> jacobian(const gtsam::Ordering& ordering) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Matrix augmentedHessian() const;
Added matlab interfaces to GaussianFactorGraph to use ordered dense hessians/jacobians
2013-10-30 23:54:03 +08:00
Matrix augmentedHessian(const gtsam::Ordering& ordering) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
pair<Matrix,Vector> hessian() const;
Added matlab interfaces to GaussianFactorGraph to use ordered dense hessians/jacobians
2013-10-30 23:54:03 +08:00
pair<Matrix,Vector> hessian(const gtsam::Ordering& ordering) const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Re-instaed deleted classes
2011-10-23 03:42:02 +08:00
};
Added back the matlab interface to gtsam
2011-10-14 02:41:56 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/linear/GaussianConditional.h>
virtual class GaussianConditional : gtsam::GaussianFactor {
add KeyGroupMap to wrap ISAM2 update with group ordering to matlab. Wrap at() in SymbolicBayesNet, and GaussianConditional constructors with no noise model.
2013-12-04 22:36:13 +08:00
//Constructors
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
GaussianConditional(size_t key, Vector d, Matrix R, const gtsam::noiseModel::Diagonal* sigmas);
GaussianConditional(size_t key, Vector d, Matrix R, size_t name1, Matrix S,
const gtsam::noiseModel::Diagonal* sigmas);
GaussianConditional(size_t key, Vector d, Matrix R, size_t name1, Matrix S,
size_t name2, Matrix T, const gtsam::noiseModel::Diagonal* sigmas);
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
add KeyGroupMap to wrap ISAM2 update with group ordering to matlab. Wrap at() in SymbolicBayesNet, and GaussianConditional constructors with no noise model.
2013-12-04 22:36:13 +08:00
//Constructors with no noise model
GaussianConditional(size_t key, Vector d, Matrix R);
GaussianConditional(size_t key, Vector d, Matrix R, size_t name1, Matrix S);
GaussianConditional(size_t key, Vector d, Matrix R, size_t name1, Matrix S,
size_t name2, Matrix T);
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
//Standard Interface
void print(string s) const;
bool equals(const gtsam::GaussianConditional &cg, double tol) const;
//Advanced Interface
gtsam::VectorValues solve(const gtsam::VectorValues& parents) const;
gtsam::VectorValues solveOtherRHS(const gtsam::VectorValues& parents, const gtsam::VectorValues& rhs) const;
void solveTransposeInPlace(gtsam::VectorValues& gy) const;
void scaleFrontalsBySigma(gtsam::VectorValues& gy) const;
python wrapper: access to gaussian conditional matrices
2020-01-15 10:28:18 +08:00
Matrix R() const;
Matrix S() const;
Vector d() const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
};
#include <gtsam/linear/GaussianDensity.h>
virtual class GaussianDensity : gtsam::GaussianConditional {
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
//Constructors
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
GaussianDensity(size_t key, Vector d, Matrix R, const gtsam::noiseModel::Diagonal* sigmas);
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
//Standard Interface
void print(string s) const;
bool equals(const gtsam::GaussianDensity &cg, double tol) const;
Vector mean() const;
Matrix covariance() const;
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
};
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/linear/GaussianBayesNet.h>
virtual class GaussianBayesNet {
//Constructors
GaussianBayesNet();
GaussianBayesNet(const gtsam::GaussianConditional* conditional);
Deprecated some more methods
2016-02-09 07:16:11 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::GaussianBayesNet& other, double tol) const;
Exposed more interfaces for working with linear graphs and bayes nets
2013-10-31 05:34:52 +08:00
size_t size() const;
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
Exposed more interfaces for working with linear graphs and bayes nets
2013-10-31 05:34:52 +08:00
// FactorGraph derived interface
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
// size_t size() const;
Exposed more interfaces for working with linear graphs and bayes nets
2013-10-31 05:34:52 +08:00
gtsam::GaussianConditional* at(size_t idx) const;
gtsam::KeySet keys() const;
bool exists(size_t idx) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::GaussianConditional* front() const;
gtsam::GaussianConditional* back() const;
void push_back(gtsam::GaussianConditional* conditional);
void push_back(const gtsam::GaussianBayesNet& bayesNet);
Deprecated some more methods
2016-02-09 07:16:11 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::VectorValues optimize() const;
Optimize an incomplete BayesNet
2014-05-06 14:18:52 +08:00
gtsam::VectorValues optimize(gtsam::VectorValues& solutionForMissing) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::VectorValues optimizeGradientSearch() const;
gtsam::VectorValues gradient(const gtsam::VectorValues& x0) const;
gtsam::VectorValues gradientAtZero() const;
double error(const gtsam::VectorValues& x) const;
double determinant() const;
double logDeterminant() const;
gtsam::VectorValues backSubstitute(const gtsam::VectorValues& gx) const;
gtsam::VectorValues backSubstituteTranspose(const gtsam::VectorValues& gx) const;
};
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/linear/GaussianBayesTree.h>
virtual class GaussianBayesTree {
// Standard Constructors and Named Constructors
GaussianBayesTree();
GaussianBayesTree(const gtsam::GaussianBayesTree& other);
bool equals(const gtsam::GaussianBayesTree& other, double tol) const;
void print(string s);
size_t size() const;
bool empty() const;
size_t numCachedSeparatorMarginals() const;
saveGraph
2012-06-07 21:17:46 +08:00
void saveGraph(string s) const;
Deprecated some more methods
2016-02-09 07:16:11 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::VectorValues optimize() const;
gtsam::VectorValues optimizeGradientSearch() const;
gtsam::VectorValues gradient(const gtsam::VectorValues& x0) const;
gtsam::VectorValues gradientAtZero() const;
double error(const gtsam::VectorValues& x) const;
double determinant() const;
double logDeterminant() const;
Re-factored iSAM MATLAB example and wrapped more ISAM functions
2012-06-07 13:19:43 +08:00
Matrix marginalCovariance(size_t key) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::GaussianConditional* marginalFactor(size_t key) const;
gtsam::GaussianFactorGraph* joint(size_t key1, size_t key2) const;
Re-factored iSAM MATLAB example and wrapped more ISAM functions
2012-06-07 13:19:43 +08:00
gtsam::GaussianBayesNet* jointBayesNet(size_t key1, size_t key2) const;
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/linear/Errors.h>
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
class Errors {
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
//Constructors
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
Errors();
Errors(const gtsam::VectorValues& V);
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
//Testable
void print(string s);
bool equals(const gtsam::Errors& expected, double tol) const;
Removed extraneous headers that were previously needed for wrap, added start of simulated2D and simulated2DOriented domains to gtsam.h, more wrap documentation
2011-12-10 00:36:50 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/linear/GaussianISAM.h>
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
class GaussianISAM {
//Constructor
GaussianISAM();
Wrapped GaussianMultifrontalSolver
2012-10-28 03:45:30 +08:00
//Standard Interface
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
void update(const gtsam::GaussianFactorGraph& newFactors);
void saveGraph(string s) const;
void clear();
Wrapped GaussianMultifrontalSolver
2012-10-28 03:45:30 +08:00
};
wrap iterative solver, subgraph solver, etc. fix the matlab spcg example
2012-09-04 05:50:22 +08:00
#include <gtsam/linear/IterativeSolver.h>
virtual class IterativeOptimizationParameters {
string getVerbosity() const;
void setVerbosity(string s) ;
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
void print() const;
wrap iterative solver, subgraph solver, etc. fix the matlab spcg example
2012-09-04 05:50:22 +08:00
};
//virtual class IterativeSolver {
// IterativeSolver();
// gtsam::VectorValues optimize ();
//};
#include <gtsam/linear/ConjugateGradientSolver.h>
virtual class ConjugateGradientParameters : gtsam::IterativeOptimizationParameters {
ConjugateGradientParameters();
Fixed several warnings
2013-11-19 22:04:52 +08:00
int getMinIterations() const ;
int getMaxIterations() const ;
int getReset() const;
wrap iterative solver, subgraph solver, etc. fix the matlab spcg example
2012-09-04 05:50:22 +08:00
double getEpsilon_rel() const;
double getEpsilon_abs() const;
Fixed several warnings
2013-11-19 22:04:52 +08:00
void setMinIterations(int value);
void setMaxIterations(int value);
void setReset(int value);
wrap iterative solver, subgraph solver, etc. fix the matlab spcg example
2012-09-04 05:50:22 +08:00
void setEpsilon_rel(double value);
void setEpsilon_abs(double value);
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
void print() const;
wrap iterative solver, subgraph solver, etc. fix the matlab spcg example
2012-09-04 05:50:22 +08:00
};
#include <gtsam/linear/SubgraphSolver.h>
virtual class SubgraphSolverParameters : gtsam::ConjugateGradientParameters {
SubgraphSolverParameters();
make the print message with consistent format
2013-01-03 10:50:55 +08:00
void print() const;
wrap iterative solver, subgraph solver, etc. fix the matlab spcg example
2012-09-04 05:50:22 +08:00
};
fix matlab toolbox compilation error
2014-06-18 01:47:43 +08:00
virtual class SubgraphSolver {
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
SubgraphSolver(const gtsam::GaussianFactorGraph &A, const gtsam::SubgraphSolverParameters &parameters, const gtsam::Ordering& ordering);
Fix SubgraphSolver wrapper
2019-04-05 20:10:27 +08:00
SubgraphSolver(const gtsam::GaussianFactorGraph &Ab1, const gtsam::GaussianFactorGraph* Ab2, const gtsam::SubgraphSolverParameters &parameters, const gtsam::Ordering& ordering);
wrap iterative solver, subgraph solver, etc. fix the matlab spcg example
2012-09-04 05:50:22 +08:00
gtsam::VectorValues optimize() const;
};
Simplified include handling in wrap: no more default includes, includes are not associated with a class or a namespace.
2012-07-18 02:30:02 +08:00
#include <gtsam/linear/KalmanFilter.h>
Wrapped KalmanFilter and tested it in MATLAB
2011-11-04 08:27:02 +08:00
class KalmanFilter {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
KalmanFilter(size_t n);
// gtsam::GaussianDensity* init(Vector x0, const gtsam::SharedDiagonal& P0);
gtsam::GaussianDensity* init(Vector x0, Matrix P0);
void print(string s) const;
Fixed indexing problem in KalmanFilter in a different way - now just modify the indices before solving and put them back afterwards, so that the timestep is still available
2013-07-05 23:46:07 +08:00
static size_t step(gtsam::GaussianDensity* p);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::GaussianDensity* predict(gtsam::GaussianDensity* p, Matrix F,
Matrix B, Vector u, const gtsam::noiseModel::Diagonal* modelQ);
gtsam::GaussianDensity* predictQ(gtsam::GaussianDensity* p, Matrix F,
Matrix B, Vector u, Matrix Q);
gtsam::GaussianDensity* predict2(gtsam::GaussianDensity* p, Matrix A0,
Matrix A1, Vector b, const gtsam::noiseModel::Diagonal* model);
gtsam::GaussianDensity* update(gtsam::GaussianDensity* p, Matrix H,
Vector z, const gtsam::noiseModel::Diagonal* model);
gtsam::GaussianDensity* updateQ(gtsam::GaussianDensity* p, Matrix H,
Vector z, Matrix Q);
Wrapped KalmanFilter and tested it in MATLAB
2011-11-04 08:27:02 +08:00
};
Additional Kalman filter constructor takes covariance
2012-01-18 04:04:37 +08:00
//*************************************************************************
// nonlinear
//*************************************************************************
Moved Symbol and LabeledSymbol to inference as they are no longer specific to nonlinear optimization
2013-08-19 23:32:16 +08:00
#include <gtsam/inference/Symbol.h>
Finished denamespacing and reorganizing matlab code
2012-07-28 03:02:11 +08:00
size_t symbol(char chr, size_t index);
char symbolChr(size_t key);
size_t symbolIndex(size_t key);
Added marginals in MATLAB, but had to fix a bug in converting from 64 bit ints to size_t. This begs the question what happens on 32-bit machines with Symbols.
2012-05-23 03:01:40 +08:00
Moved LabeledSymbol from MastSLAM with some key-related utilities
2013-05-01 02:41:06 +08:00
// Default keyformatter
Values::keys now returns KeyVector instead of list. Corresponding fixes in Matlab wrapper.
2015-06-24 12:35:32 +08:00
void PrintKeyList (const gtsam::KeyList& keys);
void PrintKeyList (const gtsam::KeyList& keys, string s);
void PrintKeyVector(const gtsam::KeyVector& keys);
void PrintKeyVector(const gtsam::KeyVector& keys, string s);
void PrintKeySet (const gtsam::KeySet& keys);
void PrintKeySet (const gtsam::KeySet& keys, string s);
Moved LabeledSymbol from MastSLAM with some key-related utilities
2013-05-01 02:41:06 +08:00
Moved Symbol and LabeledSymbol to inference as they are no longer specific to nonlinear optimization
2013-08-19 23:32:16 +08:00
#include <gtsam/inference/LabeledSymbol.h>
Moved LabeledSymbol from MastSLAM with some key-related utilities
2013-05-01 02:41:06 +08:00
class LabeledSymbol {
LabeledSymbol(size_t full_key);
LabeledSymbol(const gtsam::LabeledSymbol& key);
LabeledSymbol(unsigned char valType, unsigned char label, size_t j);
size_t key() const;
unsigned char label() const;
unsigned char chr() const;
size_t index() const;
gtsam::LabeledSymbol upper() const;
gtsam::LabeledSymbol lower() const;
Added small test and additional interface wrapping for LabeledSymbol
2013-11-24 03:11:43 +08:00
gtsam::LabeledSymbol newChr(unsigned char c) const;
gtsam::LabeledSymbol newLabel(unsigned char label) const;
Moved LabeledSymbol from MastSLAM with some key-related utilities
2013-05-01 02:41:06 +08:00
void print(string s) const;
};
Moved utility functions and formatter from LabeledSymbol to Key. Added namespace functions
2013-05-04 00:21:47 +08:00
size_t mrsymbol(unsigned char c, unsigned char label, size_t j);
unsigned char mrsymbolChr(size_t key);
unsigned char mrsymbolLabel(size_t key);
size_t mrsymbolIndex(size_t key);
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
#include <gtsam/inference/Ordering.h>
wrapped Pose2.compose
2011-11-04 12:27:55 +08:00
class Ordering {
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
// Standard Constructors and Named Constructors
Ordering();
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
Ordering(const gtsam::Ordering& other);
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::Ordering& ord, double tol) const;
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Standard interface
Added several inference-level classes to the matlab wrapper
2012-06-22 07:53:49 +08:00
size_t size() const;
size_t at(size_t key) const;
void push_back(size_t key);
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
wrapping PlanarSLAMExample_easy
2011-10-22 00:56:50 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/nonlinear/NonlinearFactorGraph.h>
Dependency checking requires class definitions for all gtsam classes used in arguments of wrapped objects
2012-05-22 06:32:40 +08:00
class NonlinearFactorGraph {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
NonlinearFactorGraph();
NonlinearFactorGraph(const gtsam::NonlinearFactorGraph& graph);
// FactorGraph
void print(string s) const;
bool equals(const gtsam::NonlinearFactorGraph& fg, double tol) const;
size_t size() const;
bool empty() const;
void remove(size_t i);
wrap more functions
2017-05-16 02:42:45 +08:00
void replace(size_t i, gtsam::NonlinearFactor* factors);
void resize(size_t size);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
size_t nrFactors() const;
Added exists() to FactorGraph to allow for checking whether a factor exists at a given index. Necessary for matlab interface.
2013-06-07 02:07:55 +08:00
gtsam::NonlinearFactor* at(size_t idx) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void push_back(const gtsam::NonlinearFactorGraph& factors);
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
void push_back(gtsam::NonlinearFactor* factor);
Added back factor graph .add functions to maintain compatibility
2013-08-27 23:30:02 +08:00
void add(gtsam::NonlinearFactor* factor);
Added exists() as a utility for matlab to check whether a pointer is live
2013-08-24 04:06:08 +08:00
bool exists(size_t idx) const;
wrap keys for GaussianFactor
2014-10-19 12:35:18 +08:00
gtsam::KeySet keys() const;
wrap more functions
2017-05-16 02:42:45 +08:00
gtsam::KeyVector keyVector() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// NonlinearFactorGraph
Add better error reporting
2019-06-15 23:11:11 +08:00
void printErrors(const gtsam::Values& values) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
double error(const gtsam::Values& values) const;
double probPrime(const gtsam::Values& values) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::Ordering orderingCOLAMD() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Ordering* orderingCOLAMDConstrained(const gtsam::Values& c, const std::map<gtsam::Key,int>& constraints) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::GaussianFactorGraph* linearize(const gtsam::Values& values) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::NonlinearFactorGraph clone() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Dependency checking requires class definitions for all gtsam classes used in arguments of wrapped objects
2012-05-22 06:32:40 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/nonlinear/NonlinearFactor.h>
Wrapped additional functions in factors and factor graphs, added factor heirarchy, fixed mistake in noisemodel heirarchy
2012-07-12 02:18:57 +08:00
virtual class NonlinearFactor {
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
// Factor base class
size_t size() const;
gtsam::KeyVector keys() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void print(string s) const;
void printKeys(string s) const;
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
// NonlinearFactor
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
bool equals(const gtsam::NonlinearFactor& other, double tol) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
double error(const gtsam::Values& c) const;
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
size_t dim() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
bool active(const gtsam::Values& c) const;
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::GaussianFactor* linearize(const gtsam::Values& c) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::NonlinearFactor* clone() const;
// gtsam::NonlinearFactor* rekey(const gtsam::KeyVector& newKeys) const; //FIXME: Conversion from KeyVector to std::vector does not happen
Added wrapping for NonlinearFactor to allow for access to keys from an individual key
2012-06-15 00:03:57 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/nonlinear/NonlinearFactor.h>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class NoiseModelFactor: gtsam::NonlinearFactor {
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
bool equals(const gtsam::NoiseModelFactor& other, double tol) const;
Many small improvements, bug-fixes, and tests
2016-02-25 03:01:19 +08:00
gtsam::noiseModel::Base* noiseModel() const;
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
Vector unwhitenedError(const gtsam::Values& x) const;
Vector whitenedError(const gtsam::Values& x) const;
};
Added full Values interface
2012-08-08 02:21:35 +08:00
#include <gtsam/nonlinear/Values.h>
Dependency checking requires class definitions for all gtsam classes used in arguments of wrapped objects
2012-05-22 06:32:40 +08:00
class Values {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Values();
Values(const gtsam::Values& other);
Added full Values interface
2012-08-08 02:21:35 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
size_t size() const;
bool empty() const;
Rearranged serialization test to use new interface, added serialize() flags to Point2 and Values. Serialzing values fails - now to add export commands
2013-06-20 01:50:01 +08:00
void clear();
size_t dim() const;
Added full Values interface
2012-08-08 02:21:35 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void print(string s) const;
bool equals(const gtsam::Values& other, double tol) const;
Added full Values interface
2012-08-08 02:21:35 +08:00
Rearranged serialization test to use new interface, added serialize() flags to Point2 and Values. Serialzing values fails - now to add export commands
2013-06-20 01:50:01 +08:00
void insert(const gtsam::Values& values);
void update(const gtsam::Values& values);
void erase(size_t j);
void swap(gtsam::Values& values);
Added full Values interface
2012-08-08 02:21:35 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
bool exists(size_t j) const;
Values::keys now returns KeyVector instead of list. Corresponding fixes in Matlab wrapper.
2015-06-24 12:35:32 +08:00
gtsam::KeyVector keys() const;
Added full Values interface
2012-08-08 02:21:35 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::VectorValues zeroVectors() const;
Rearranged serialization test to use new interface, added serialize() flags to Point2 and Values. Serialzing values fails - now to add export commands
2013-06-20 01:50:01 +08:00
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
gtsam::Values retract(const gtsam::VectorValues& delta) const;
gtsam::VectorValues localCoordinates(const gtsam::Values& cp) const;
Added full Values interface
2012-08-08 02:21:35 +08:00
Rearranged serialization test to use new interface, added serialize() flags to Point2 and Values. Serialzing values fails - now to add export commands
2013-06-20 01:50:01 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Added virtual destructor: for some reason if I remove virtual methods the unit tests fail...
2014-11-10 23:43:49 +08:00
slight refactor
2014-11-11 20:42:13 +08:00
// New in 4.0, we have to specialize every insert/update/at to generate wrappers
Added virtual destructor: for some reason if I remove virtual methods the unit tests fail...
2014-11-10 23:43:49 +08:00
// Instead of the old:
// void insert(size_t j, const gtsam::Value& value);
// void update(size_t j, const gtsam::Value& val);
slight refactor
2014-11-11 20:42:13 +08:00
// gtsam::Value at(size_t j) const;
We will not wrap fixed Vectors and Matrices individually. Methods that take those can just as well be wrapped with Vector or Matrix. Note const and & are ignored for those. I added a small method, insertFixed, that allows one to put in small fixed size matrices for optimization. Did not do retrieval yet.
2014-12-10 17:43:08 +08:00
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
void insert(size_t j, const gtsam::Point2& point2);
void insert(size_t j, const gtsam::Point3& point3);
void insert(size_t j, const gtsam::Rot2& rot2);
void insert(size_t j, const gtsam::Pose2& pose2);
Wrapped SO(3), SO(4) and new factor, and added SO(4) tests in python
2019-04-17 12:07:38 +08:00
void insert(size_t j, const gtsam::SO3& R);
void insert(size_t j, const gtsam::SO4& Q);
Made constructor explicit, expose SOn in wrapper
2019-04-21 04:49:20 +08:00
void insert(size_t j, const gtsam::SOn& P);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
void insert(size_t j, const gtsam::Rot3& rot3);
void insert(size_t j, const gtsam::Pose3& pose3);
void insert(size_t j, const gtsam::Cal3_S2& cal3_s2);
void insert(size_t j, const gtsam::Cal3DS2& cal3ds2);
void insert(size_t j, const gtsam::Cal3Bundler& cal3bundler);
void insert(size_t j, const gtsam::EssentialMatrix& essential_matrix);
replaced/appended all calls to SimpleCamera with PinholeCameraCal3_S2
2020-02-22 08:42:55 +08:00
void insert(size_t j, const gtsam::PinholeCameraCal3_S2& simple_camera);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
void insert(size_t j, const gtsam::imuBias::ConstantBias& constant_bias);
void insert(size_t j, Vector vector);
void insert(size_t j, Matrix matrix);
void update(size_t j, const gtsam::Point2& point2);
void update(size_t j, const gtsam::Point3& point3);
void update(size_t j, const gtsam::Rot2& rot2);
void update(size_t j, const gtsam::Pose2& pose2);
Wrapped SO(3), SO(4) and new factor, and added SO(4) tests in python
2019-04-17 12:07:38 +08:00
void update(size_t j, const gtsam::SO3& R);
void update(size_t j, const gtsam::SO4& Q);
Made constructor explicit, expose SOn in wrapper
2019-04-21 04:49:20 +08:00
void update(size_t j, const gtsam::SOn& P);
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
void update(size_t j, const gtsam::Rot3& rot3);
void update(size_t j, const gtsam::Pose3& pose3);
void update(size_t j, const gtsam::Cal3_S2& cal3_s2);
void update(size_t j, const gtsam::Cal3DS2& cal3ds2);
void update(size_t j, const gtsam::Cal3Bundler& cal3bundler);
void update(size_t j, const gtsam::EssentialMatrix& essential_matrix);
void update(size_t j, const gtsam::imuBias::ConstantBias& constant_bias);
void update(size_t j, Vector vector);
void update(size_t j, Matrix matrix);
Added Mike's desired code snippet
2014-11-10 23:44:48 +08:00
Made constructor explicit, expose SOn in wrapper
2019-04-21 04:49:20 +08:00
template<T = {gtsam::Point2, gtsam::Point3, gtsam::Rot2, gtsam::Pose2, gtsam::SO3, gtsam::SO4, gtsam::SOn, gtsam::Rot3, gtsam::Pose3, gtsam::Cal3_S2, gtsam::Cal3DS2, gtsam::Cal3Bundler, gtsam::EssentialMatrix, gtsam::imuBias::ConstantBias, Vector, Matrix}>
gtsam.h with templated Values::at now compiles !
2014-11-13 08:26:06 +08:00
T at(size_t j);
Fixed and double versions
2014-12-19 22:40:43 +08:00
/// version for double
void insertDouble(size_t j, double c);
double atDouble(size_t j) const;
Dependency checking requires class definitions for all gtsam classes used in arguments of wrapped objects
2012-05-22 06:32:40 +08:00
};
Added required header files to gtsam.h
2012-07-23 23:33:39 +08:00
#include <gtsam/nonlinear/Marginals.h>
Dependency checking requires class definitions for all gtsam classes used in arguments of wrapped objects
2012-05-22 06:32:40 +08:00
class Marginals {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Marginals(const gtsam::NonlinearFactorGraph& graph,
const gtsam::Values& solution);
Gaussian Factor Graph unittests and linearization (with Python bindings)
2019-10-10 03:58:57 +08:00
Marginals(const gtsam::GaussianFactorGraph& gfgraph,
const gtsam::Values& solution);
Marginals(const gtsam::GaussianFactorGraph& gfgraph,
const gtsam::VectorValues& solutionvec);
Fixed Dynamics Factor and added debug cout statements to help fix indeterminent linear system exception
2014-10-15 06:08:26 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void print(string s) const;
Matrix marginalCovariance(size_t variable) const;
Matrix marginalInformation(size_t variable) const;
gtsam::JointMarginal jointMarginalCovariance(const gtsam::KeyVector& variables) const;
gtsam::JointMarginal jointMarginalInformation(const gtsam::KeyVector& variables) const;
Wrapped JointMarginal class and joint marginal functions of Marginals
2012-07-22 07:54:55 +08:00
};
class JointMarginal {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
Matrix at(size_t iVariable, size_t jVariable) const;
Matrix fullMatrix() const;
void print(string s) const;
void print() const;
Dependency checking requires class definitions for all gtsam classes used in arguments of wrapped objects
2012-05-22 06:32:40 +08:00
};
Added (commented out) marginals class
2012-05-22 05:53:56 +08:00
Moved LinearContainerFactor to gtsam/nonlinear and removed the now-redundant LinearizedFactor from gtsam_unstable
2012-11-22 03:41:24 +08:00
#include <gtsam/nonlinear/LinearContainerFactor.h>
virtual class LinearContainerFactor : gtsam::NonlinearFactor {
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
LinearContainerFactor(gtsam::GaussianFactor* factor, const gtsam::Values& linearizationPoint);
Moved LinearContainerFactor to gtsam/nonlinear and removed the now-redundant LinearizedFactor from gtsam_unstable
2012-11-22 03:41:24 +08:00
LinearContainerFactor(gtsam::GaussianFactor* factor);
gtsam::GaussianFactor* factor() const;
// const boost::optional<Values>& linearizationPoint() const;
bool isJacobian() const;
gtsam::JacobianFactor* toJacobian() const;
gtsam::HessianFactor* toHessian() const;
Attempt at fixing matlab wrapper issues
2016-06-20 16:11:57 +08:00
static gtsam::NonlinearFactorGraph ConvertLinearGraph(const gtsam::GaussianFactorGraph& linear_graph,
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
const gtsam::Values& linearizationPoint);
Moved LinearContainerFactor to gtsam/nonlinear and removed the now-redundant LinearizedFactor from gtsam_unstable
2012-11-22 03:41:24 +08:00
Attempt at fixing matlab wrapper issues
2016-06-20 16:11:57 +08:00
static gtsam::NonlinearFactorGraph ConvertLinearGraph(const gtsam::GaussianFactorGraph& linear_graph);
Moved LinearContainerFactor to gtsam/nonlinear and removed the now-redundant LinearizedFactor from gtsam_unstable
2012-11-22 03:41:24 +08:00
Serialized more classes in gtsam and gtsam_unstable
2013-06-20 01:50:07 +08:00
// enabling serialization functionality
void serializable() const;
Moved LinearContainerFactor to gtsam/nonlinear and removed the now-redundant LinearizedFactor from gtsam_unstable
2012-11-22 03:41:24 +08:00
}; // \class LinearContainerFactor
Moved older functions back to gtsam_unstable, cleanup. All tests pass. Rearranged summarization wrap interfaces.
2013-05-08 18:13:57 +08:00
// Summarization functionality
comment out summarization in gtsam.h, since summarization.h disappeared.
2013-08-20 01:06:28 +08:00
//#include <gtsam/nonlinear/summarization.h>
//
//// Uses partial QR approach by default
//gtsam::GaussianFactorGraph summarize(
// const gtsam::NonlinearFactorGraph& graph, const gtsam::Values& values,
// const gtsam::KeySet& saved_keys);
//
//gtsam::NonlinearFactorGraph summarizeAsNonlinearContainer(
// const gtsam::NonlinearFactorGraph& graph, const gtsam::Values& values,
// const gtsam::KeySet& saved_keys);
Moved older functions back to gtsam_unstable, cleanup. All tests pass. Rearranged summarization wrap interfaces.
2013-05-08 18:13:57 +08:00
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
//*************************************************************************
// Nonlinear optimizers
//*************************************************************************
Merged NonlinearSolverParams in gtsam.h into NonlinearOptimizerParams, removed references to NonlinearSolverParams elsewhere in comments
2013-10-26 03:47:22 +08:00
#include <gtsam/nonlinear/NonlinearOptimizerParams.h>
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
virtual class NonlinearOptimizerParams {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
NonlinearOptimizerParams();
void print(string s) const;
Allow more parameters to be set
2012-07-04 23:41:19 +08:00
Fixed several warnings
2013-11-19 22:04:52 +08:00
int getMaxIterations() const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
double getRelativeErrorTol() const;
double getAbsoluteErrorTol() const;
double getErrorTol() const;
string getVerbosity() const;
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
Fixed several warnings
2013-11-19 22:04:52 +08:00
void setMaxIterations(int value);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void setRelativeErrorTol(double value);
void setAbsoluteErrorTol(double value);
void setErrorTol(double value);
void setVerbosity(string s);
Allow more parameters to be set
2012-07-04 23:41:19 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
string getLinearSolverType() const;
void setLinearSolverType(string solver);
Better optimization parameter wrapping, plus python test
2019-03-19 12:11:45 +08:00
fix matlab toolbox compilation error
2014-06-18 01:47:43 +08:00
void setIterativeParams(gtsam::IterativeOptimizationParameters* params);
Better optimization parameter wrapping, plus python test
2019-03-19 12:11:45 +08:00
void setOrdering(const gtsam::Ordering& ordering);
string getOrderingType() const;
void setOrderingType(string ordering);
Added support for SPCG in matlab wrapper
2012-07-24 23:48:33 +08:00
Allow more parameters to be set
2012-07-04 23:41:19 +08:00
bool isMultifrontal() const;
bool isSequential() const;
bool isCholmod() const;
remove unused variables in iterative solvers and rename accordingly.
2014-06-04 11:52:35 +08:00
bool isIterative() const;
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
};
Merged NonlinearSolverParams in gtsam.h into NonlinearOptimizerParams, removed references to NonlinearSolverParams elsewhere in comments
2013-10-26 03:47:22 +08:00
bool checkConvergence(double relativeErrorTreshold,
double absoluteErrorTreshold, double errorThreshold,
double currentError, double newError);
Added support for SPCG in matlab wrapper
2012-07-24 23:48:33 +08:00
#include <gtsam/nonlinear/GaussNewtonOptimizer.h>
Merged NonlinearSolverParams in gtsam.h into NonlinearOptimizerParams, removed references to NonlinearSolverParams elsewhere in comments
2013-10-26 03:47:22 +08:00
virtual class GaussNewtonParams : gtsam::NonlinearOptimizerParams {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
GaussNewtonParams();
Added support for SPCG in matlab wrapper
2012-07-24 23:48:33 +08:00
};
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
#include <gtsam/nonlinear/LevenbergMarquardtOptimizer.h>
Merged NonlinearSolverParams in gtsam.h into NonlinearOptimizerParams, removed references to NonlinearSolverParams elsewhere in comments
2013-10-26 03:47:22 +08:00
virtual class LevenbergMarquardtParams : gtsam::NonlinearOptimizerParams {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
LevenbergMarquardtParams();
Allow more parameters to be set
2012-07-04 23:41:19 +08:00
Better optimization parameter wrapping, plus python test
2019-03-19 12:11:45 +08:00
bool getDiagonalDamping() const;
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
double getlambdaFactor() const;
Better optimization parameter wrapping, plus python test
2019-03-19 12:11:45 +08:00
double getlambdaInitial() const;
double getlambdaLowerBound() const;
add set/get interface for LMParameters in c++ and matlab
2012-06-24 04:07:03 +08:00
double getlambdaUpperBound() const;
Better optimization parameter wrapping, plus python test
2019-03-19 12:11:45 +08:00
bool getUseFixedLambdaFactor();
string getLogFile() const;
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
string getVerbosityLM() const;
Type for Factor indices, dual to "Key" This avoids a couple of confusing uses of KeySet to refer to lists of Factors, and makes code more readable where formerly using size_t to index factors.
2019-02-27 15:50:50 +08:00
Better optimization parameter wrapping, plus python test
2019-03-19 12:11:45 +08:00
void setDiagonalDamping(bool flag);
add set/get interface for LMParameters in c++ and matlab
2012-06-24 04:07:03 +08:00
void setlambdaFactor(double value);
Better optimization parameter wrapping, plus python test
2019-03-19 12:11:45 +08:00
void setlambdaInitial(double value);
void setlambdaLowerBound(double value);
add set/get interface for LMParameters in c++ and matlab
2012-06-24 04:07:03 +08:00
void setlambdaUpperBound(double value);
Better optimization parameter wrapping, plus python test
2019-03-19 12:11:45 +08:00
void setUseFixedLambdaFactor(bool flag);
void setLogFile(string s);
add set/get interface for LMParameters in c++ and matlab
2012-06-24 04:07:03 +08:00
void setVerbosityLM(string s);
Better optimization parameter wrapping, plus python test
2019-03-19 12:11:45 +08:00
static gtsam::LevenbergMarquardtParams LegacyDefaults();
static gtsam::LevenbergMarquardtParams CeresDefaults();
static gtsam::LevenbergMarquardtParams EnsureHasOrdering(
gtsam::LevenbergMarquardtParams params,
const gtsam::NonlinearFactorGraph& graph);
static gtsam::LevenbergMarquardtParams ReplaceOrdering(
gtsam::LevenbergMarquardtParams params, const gtsam::Ordering& ordering);
(With Duy) add a matlab wrapper for the LM optimizer and parameters in visualSLAM, have an example in SFMExample.m
2012-06-21 22:28:08 +08:00
};
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
#include <gtsam/nonlinear/DoglegOptimizer.h>
Merged NonlinearSolverParams in gtsam.h into NonlinearOptimizerParams, removed references to NonlinearSolverParams elsewhere in comments
2013-10-26 03:47:22 +08:00
virtual class DoglegParams : gtsam::NonlinearOptimizerParams {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
DoglegParams();
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
double getDeltaInitial() const;
string getVerbosityDL() const;
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
void setDeltaInitial(double deltaInitial) const;
void setVerbosityDL(string verbosityDL) const;
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/nonlinear/NonlinearOptimizer.h>
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
virtual class NonlinearOptimizer {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::Values optimize();
gtsam::Values optimizeSafely();
double error() const;
int iterations() const;
gtsam::Values values() const;
Add return argument
2019-05-17 08:49:52 +08:00
gtsam::GaussianFactorGraph* iterate() const;
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/nonlinear/GaussNewtonOptimizer.h>
Added support for SPCG in matlab wrapper
2012-07-24 23:48:33 +08:00
virtual class GaussNewtonOptimizer : gtsam::NonlinearOptimizer {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
GaussNewtonOptimizer(const gtsam::NonlinearFactorGraph& graph, const gtsam::Values& initialValues);
GaussNewtonOptimizer(const gtsam::NonlinearFactorGraph& graph, const gtsam::Values& initialValues, const gtsam::GaussNewtonParams& params);
Added support for SPCG in matlab wrapper
2012-07-24 23:48:33 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/nonlinear/DoglegOptimizer.h>
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
virtual class DoglegOptimizer : gtsam::NonlinearOptimizer {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
DoglegOptimizer(const gtsam::NonlinearFactorGraph& graph, const gtsam::Values& initialValues);
DoglegOptimizer(const gtsam::NonlinearFactorGraph& graph, const gtsam::Values& initialValues, const gtsam::DoglegParams& params);
double getDelta() const;
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
};
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
#include <gtsam/nonlinear/LevenbergMarquardtOptimizer.h>
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
virtual class LevenbergMarquardtOptimizer : gtsam::NonlinearOptimizer {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
LevenbergMarquardtOptimizer(const gtsam::NonlinearFactorGraph& graph, const gtsam::Values& initialValues);
LevenbergMarquardtOptimizer(const gtsam::NonlinearFactorGraph& graph, const gtsam::Values& initialValues, const gtsam::LevenbergMarquardtParams& params);
double lambda() const;
Added print for LMOptimizer
2012-08-05 04:32:23 +08:00
void print(string str) const;
Wrapped DoglegOptimizer and LevenbergMarquardtOptimizer, added class heirarchy to optimization parameters
2012-07-19 07:35:36 +08:00
};
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
#include <gtsam/nonlinear/ISAM2.h>
class ISAM2GaussNewtonParams {
ISAM2GaussNewtonParams();
void print(string str) const;
/** Getters and Setters for all properties */
double getWildfireThreshold() const;
void setWildfireThreshold(double wildfireThreshold);
};
class ISAM2DoglegParams {
ISAM2DoglegParams();
void print(string str) const;
/** Getters and Setters for all properties */
double getWildfireThreshold() const;
void setWildfireThreshold(double wildfireThreshold);
double getInitialDelta() const;
void setInitialDelta(double initialDelta);
string getAdaptationMode() const;
void setAdaptationMode(string adaptationMode);
bool isVerbose() const;
void setVerbose(bool verbose);
};
Wrapped per-variable thresholds for iSAM2
2012-07-31 05:19:24 +08:00
class ISAM2ThresholdMapValue {
ISAM2ThresholdMapValue(char c, Vector thresholds);
ISAM2ThresholdMapValue(const gtsam::ISAM2ThresholdMapValue& other);
};
class ISAM2ThresholdMap {
ISAM2ThresholdMap();
ISAM2ThresholdMap(const gtsam::ISAM2ThresholdMap& other);
// Note: no print function
// common STL methods
size_t size() const;
bool empty() const;
void clear();
// structure specific methods
void insert(const gtsam::ISAM2ThresholdMapValue& value) const;
};
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
class ISAM2Params {
ISAM2Params();
void print(string str) const;
/** Getters and Setters for all properties */
Removed kwargs overhead for overloaded methods
2017-08-07 07:53:04 +08:00
void setOptimizationParams(const gtsam::ISAM2GaussNewtonParams& gauss_newton__params);
void setOptimizationParams(const gtsam::ISAM2DoglegParams& dogleg_params);
void setRelinearizeThreshold(double threshold);
void setRelinearizeThreshold(const gtsam::ISAM2ThresholdMap& threshold_map);
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
int getRelinearizeSkip() const;
void setRelinearizeSkip(int relinearizeSkip);
bool isEnableRelinearization() const;
void setEnableRelinearization(bool enableRelinearization);
bool isEvaluateNonlinearError() const;
void setEvaluateNonlinearError(bool evaluateNonlinearError);
string getFactorization() const;
void setFactorization(string factorization);
bool isCacheLinearizedFactors() const;
void setCacheLinearizedFactors(bool cacheLinearizedFactors);
bool isEnableDetailedResults() const;
void setEnableDetailedResults(bool enableDetailedResults);
bool isEnablePartialRelinearizationCheck() const;
void setEnablePartialRelinearizationCheck(bool enablePartialRelinearizationCheck);
};
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
class ISAM2Clique {
Inherited methods show up on doc. ISAM2 for MATLAB now inherets from Bayes Tree
2012-09-09 03:51:23 +08:00
//Constructors
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
ISAM2Clique();
Inherited methods show up on doc. ISAM2 for MATLAB now inherets from Bayes Tree
2012-09-09 03:51:23 +08:00
//Standard Interface
Vector gradientContribution() const;
void print(string s);
};
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
class ISAM2Result {
ISAM2Result();
void print(string str) const;
/** Getters and Setters for all properties */
size_t getVariablesRelinearized() const;
size_t getVariablesReeliminated() const;
size_t getCliques() const;
};
Updated gtsam.h for unordered changes
2013-08-13 02:21:30 +08:00
class ISAM2 {
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
ISAM2();
ISAM2(const gtsam::ISAM2Params& params);
Wrapped ISAM2 copy constructor in MATLAB
2013-03-14 02:17:45 +08:00
ISAM2(const gtsam::ISAM2& other);
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
bool equals(const gtsam::ISAM2& other, double tol) const;
void print(string s) const;
add printStats() and wrap saveGraph for ISAM2
2012-09-04 12:17:55 +08:00
void printStats() const;
void saveGraph(string s) const;
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
gtsam::ISAM2Result update();
gtsam::ISAM2Result update(const gtsam::NonlinearFactorGraph& newFactors, const gtsam::Values& newTheta);
A better solution through typedef of FactorIndices -> FastVector<size_t>
2016-02-26 15:51:01 +08:00
gtsam::ISAM2Result update(const gtsam::NonlinearFactorGraph& newFactors, const gtsam::Values& newTheta, const gtsam::FactorIndices& removeFactorIndices);
gtsam::ISAM2Result update(const gtsam::NonlinearFactorGraph& newFactors, const gtsam::Values& newTheta, const gtsam::FactorIndices& removeFactorIndices, const gtsam::KeyGroupMap& constrainedKeys);
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
// TODO: wrap the full version of update
Added more functionality to matlab wrapper
2012-09-08 07:10:49 +08:00
//void update(const gtsam::NonlinearFactorGraph& newFactors, const gtsam::Values& newTheta, const gtsam::KeyVector& removeFactorIndices, FastMap<Key,int>& constrainedKeys);
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
//void update(const gtsam::NonlinearFactorGraph& newFactors, const gtsam::Values& newTheta, const gtsam::KeyVector& removeFactorIndices, FastMap<Key,int>& constrainedKeys, bool force_relinearize);
gtsam::Values getLinearizationPoint() const;
gtsam::Values calculateEstimate() const;
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
template <VALUE = {gtsam::Point2, gtsam::Rot2, gtsam::Pose2, gtsam::Point3,
gtsam::Rot3, gtsam::Pose3, gtsam::Cal3_S2, gtsam::Cal3DS2,
gtsam::Cal3Bundler, gtsam::EssentialMatrix,
replaced/appended all calls to SimpleCamera with PinholeCameraCal3_S2
2020-02-22 08:42:55 +08:00
gtsam::SimpleCamera, gtsam::PinholeCameraCal3_S2, Vector, Matrix}>
unify gtsam.h for matlab and cython wrapper
2017-03-19 03:33:01 +08:00
VALUE calculateEstimate(size_t key) const;
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
gtsam::Values calculateBestEstimate() const;
Brought some relevant changes from aspn-imu-factor branch (is correct this time)
2013-08-03 00:04:17 +08:00
Matrix marginalCovariance(size_t key) const;
Wrapped iSAM2
2012-07-20 03:50:00 +08:00
gtsam::VectorValues getDelta() const;
gtsam::NonlinearFactorGraph getFactorsUnsafe() const;
gtsam::VariableIndex getVariableIndex() const;
gtsam::ISAM2Params params() const;
};
Wrapped ISAM1
2012-08-04 04:23:08 +08:00
#include <gtsam/nonlinear/NonlinearISAM.h>
class NonlinearISAM {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
NonlinearISAM();
NonlinearISAM(int reorderInterval);
Wrapped ISAM1
2012-08-04 04:23:08 +08:00
void print(string s) const;
void printStats() const;
void saveGraph(string s) const;
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::Values estimate() const;
Wrapped ISAM1
2012-08-04 04:23:08 +08:00
Matrix marginalCovariance(size_t key) const;
int reorderInterval() const;
int reorderCounter() const;
void update(const gtsam::NonlinearFactorGraph& newFactors, const gtsam::Values& initialValues);
void reorder_relinearize();
// These might be expensive as instead of a reference the wrapper will make a copy
gtsam::GaussianISAM bayesTree() const;
gtsam::Values getLinearizationPoint() const;
gtsam::NonlinearFactorGraph getFactorsUnsafe() const;
};
Added templates for PriorFactor and BetweenFactor to gtsam.h
2012-07-12 05:43:19 +08:00
//*************************************************************************
// Nonlinear factor types
//*************************************************************************
Added required header files to gtsam.h
2012-07-23 23:33:39 +08:00
#include <gtsam/geometry/SimpleCamera.h>
#include <gtsam/geometry/CalibratedCamera.h>
#include <gtsam/geometry/StereoPoint2.h>
Change PriorFactor includes from gtsam/slam to gtsam/nonlinear
2020-04-11 10:26:22 +08:00
#include <gtsam/nonlinear/PriorFactor.h>
replaced/appended all calls to SimpleCamera with PinholeCameraCal3_S2
2020-02-22 08:42:55 +08:00
template<T = {Vector, gtsam::Point2, gtsam::StereoPoint2, gtsam::Point3, gtsam::Rot2, gtsam::SO3, gtsam::SO4, gtsam::Rot3, gtsam::Pose2, gtsam::Pose3, gtsam::Cal3_S2,gtsam::CalibratedCamera, gtsam::SimpleCamera, gtsam::PinholeCameraCal3_S2, gtsam::imuBias::ConstantBias}>
Changed Between and Prior Factors and NonLinearEquality back to NoiseModelFactor.
2013-08-09 00:08:35 +08:00
virtual class PriorFactor : gtsam::NoiseModelFactor {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
PriorFactor(size_t key, const T& prior, const gtsam::noiseModel::Base* noiseModel);
Added access functions to measurements and noisemodels for a variety of common nonlinear factors
2013-06-11 04:49:47 +08:00
T prior() const;
serialization works for graph and PriorFactor. Added second flag for serialization: can add "void serializable()" or "void serialize()" to allow for either just exporting (necessary if no default constructor), or implementing the full serialization functions
2013-06-20 01:50:05 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Added templates for PriorFactor and BetweenFactor to gtsam.h
2012-07-12 05:43:19 +08:00
};
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
Added required header files to gtsam.h
2012-07-23 23:33:39 +08:00
#include <gtsam/slam/BetweenFactor.h>
Merge remote-tracking branch 'origin/develop' into feature/rotation_group # Conflicts: # gtsam.h # gtsam/linear/GaussianBayesNet.cpp
2019-11-28 06:18:39 +08:00
template<T = {Vector, gtsam::Point2, gtsam::Point3, gtsam::Rot2, gtsam::SO3, gtsam::SO4, gtsam::Rot3, gtsam::Pose2, gtsam::Pose3, gtsam::imuBias::ConstantBias}>
Changed Between and Prior Factors and NonLinearEquality back to NoiseModelFactor.
2013-08-09 00:08:35 +08:00
virtual class BetweenFactor : gtsam::NoiseModelFactor {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
BetweenFactor(size_t key1, size_t key2, const T& relativePose, const gtsam::noiseModel::Base* noiseModel);
Added access functions to measurements and noisemodels for a variety of common nonlinear factors
2013-06-11 04:49:47 +08:00
T measured() const;
Serialized more classes in gtsam and gtsam_unstable
2013-06-20 01:50:07 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Added templates for PriorFactor and BetweenFactor to gtsam.h
2012-07-12 05:43:19 +08:00
};
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
wrap DistanceFactor to matlab
2014-09-27 05:21:43 +08:00
Added required header files to gtsam.h
2012-07-23 23:33:39 +08:00
#include <gtsam/nonlinear/NonlinearEquality.h>
replaced/appended all calls to SimpleCamera with PinholeCameraCal3_S2
2020-02-22 08:42:55 +08:00
template<T = {gtsam::Point2, gtsam::StereoPoint2, gtsam::Point3, gtsam::Rot2, gtsam::SO3, gtsam::SO4, gtsam::Rot3, gtsam::Pose2, gtsam::Pose3, gtsam::Cal3_S2, gtsam::CalibratedCamera, gtsam::SimpleCamera, gtsam::PinholeCameraCal3_S2, gtsam::imuBias::ConstantBias}>
Changed Between and Prior Factors and NonLinearEquality back to NoiseModelFactor.
2013-08-09 00:08:35 +08:00
virtual class NonlinearEquality : gtsam::NoiseModelFactor {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
// Constructor - forces exact evaluation
NonlinearEquality(size_t j, const T& feasible);
// Constructor - allows inexact evaluation
NonlinearEquality(size_t j, const T& feasible, double error_gain);
Serialized more classes in gtsam and gtsam_unstable
2013-06-20 01:50:07 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Wrapped NonlinearEquality and NonlinearFactorGraph::at
2012-07-14 05:55:02 +08:00
};
moved RangeFactor to SAM
2015-07-13 03:06:55 +08:00
#include <gtsam/sam/RangeFactor.h>
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
template<POSE, POINT>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class RangeFactor : gtsam::NoiseModelFactor {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
RangeFactor(size_t key1, size_t key2, double measured, const gtsam::noiseModel::Base* noiseModel);
Added serialization for two more factors
2018-12-31 05:23:43 +08:00
// enabling serialization functionality
void serialize() const;
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
};
Made naming convention in wrapper uniform. 2D means Pose2 + Point2 3D means Pose3 + Point3
2019-01-01 00:19:46 +08:00
typedef gtsam::RangeFactor<gtsam::Pose2, gtsam::Point2> RangeFactor2D;
typedef gtsam::RangeFactor<gtsam::Pose3, gtsam::Point3> RangeFactor3D;
Richard's changes of RangeFactor.
2012-07-19 23:11:11 +08:00
typedef gtsam::RangeFactor<gtsam::Pose2, gtsam::Pose2> RangeFactorPose2;
typedef gtsam::RangeFactor<gtsam::Pose3, gtsam::Pose3> RangeFactorPose3;
Define and partially specify Range and Bearing functors
2015-07-13 06:51:49 +08:00
typedef gtsam::RangeFactor<gtsam::CalibratedCamera, gtsam::Point3> RangeFactorCalibratedCameraPoint;
replaced/appended all calls to SimpleCamera with PinholeCameraCal3_S2
2020-02-22 08:42:55 +08:00
typedef gtsam::RangeFactor<gtsam::PinholeCameraCal3_S2, gtsam::Point3> RangeFactorSimpleCameraPoint;
Define and partially specify Range and Bearing functors
2015-07-13 06:51:49 +08:00
typedef gtsam::RangeFactor<gtsam::CalibratedCamera, gtsam::CalibratedCamera> RangeFactorCalibratedCamera;
replaced/appended all calls to SimpleCamera with PinholeCameraCal3_S2
2020-02-22 08:42:55 +08:00
typedef gtsam::RangeFactor<gtsam::PinholeCameraCal3_S2, gtsam::PinholeCameraCal3_S2> RangeFactorSimpleCamera;
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
Finished denamespacing and reorganizing matlab code
2012-07-28 03:02:11 +08:00
wrap RangeFactorWithTransform
2017-10-09 10:12:29 +08:00
#include <gtsam/sam/RangeFactor.h>
template<POSE, POINT>
virtual class RangeFactorWithTransform : gtsam::NoiseModelFactor {
RangeFactorWithTransform(size_t key1, size_t key2, double measured, const gtsam::noiseModel::Base* noiseModel, const POSE& body_T_sensor);
Added serialization for two more factors
2018-12-31 05:23:43 +08:00
// enabling serialization functionality
void serialize() const;
wrap RangeFactorWithTransform
2017-10-09 10:12:29 +08:00
};
Made naming convention in wrapper uniform. 2D means Pose2 + Point2 3D means Pose3 + Point3
2019-01-01 00:19:46 +08:00
typedef gtsam::RangeFactorWithTransform<gtsam::Pose2, gtsam::Point2> RangeFactorWithTransform2D;
typedef gtsam::RangeFactorWithTransform<gtsam::Pose3, gtsam::Point3> RangeFactorWithTransform3D;
wrap RangeFactorWithTransform
2017-10-09 10:12:29 +08:00
typedef gtsam::RangeFactorWithTransform<gtsam::Pose2, gtsam::Pose2> RangeFactorWithTransformPose2;
typedef gtsam::RangeFactorWithTransform<gtsam::Pose3, gtsam::Pose3> RangeFactorWithTransformPose3;
moved BearingFactor to sam
2015-07-10 03:08:28 +08:00
#include <gtsam/sam/BearingFactor.h>
Define and partially specify Range and Bearing functors
2015-07-13 06:51:49 +08:00
template<POSE, POINT, BEARING>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class BearingFactor : gtsam::NoiseModelFactor {
Define and partially specify Range and Bearing functors
2015-07-13 06:51:49 +08:00
BearingFactor(size_t key1, size_t key2, const BEARING& measured, const gtsam::noiseModel::Base* noiseModel);
Serialized more classes in gtsam and gtsam_unstable
2013-06-20 01:50:07 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
};
typedef gtsam::BearingFactor<gtsam::Pose2, gtsam::Point2, gtsam::Rot2> BearingFactor2D;
Made naming convention in wrapper uniform. 2D means Pose2 + Point2 3D means Pose3 + Point3
2019-01-01 00:19:46 +08:00
typedef gtsam::BearingFactor<gtsam::Pose2, gtsam::Pose2, gtsam::Rot2> BearingFactorPose2;
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
Wrapping BearingRange
2019-01-26 04:20:54 +08:00
#include <gtsam/geometry/BearingRange.h>
template <POSE, POINT, BEARING, RANGE>
class BearingRange {
BearingRange(const BEARING& b, const RANGE& r);
BEARING bearing() const;
RANGE range() const;
// TODO(frank): can't class instance itself?
// static gtsam::BearingRange Measure(const POSE& pose, const POINT& point);
static BEARING MeasureBearing(const POSE& pose, const POINT& point);
static RANGE MeasureRange(const POSE& pose, const POINT& point);
void print(string s) const;
};
typedef gtsam::BearingRange<gtsam::Pose2, gtsam::Point2, gtsam::Rot2, double> BearingRange2D;
Moved BearingRangeFactor to SAM
2015-07-13 09:57:26 +08:00
#include <gtsam/sam/BearingRangeFactor.h>
Fixed wrapper
2015-07-13 13:49:04 +08:00
template<POSE, POINT, BEARING, RANGE>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class BearingRangeFactor : gtsam::NoiseModelFactor {
Fixed wrapper
2015-07-13 13:49:04 +08:00
BearingRangeFactor(size_t poseKey, size_t pointKey,
const BEARING& measuredBearing, const RANGE& measuredRange,
const gtsam::noiseModel::Base* noiseModel);
Wrapped measured() for BearingRangeFactor.
2014-05-01 10:32:59 +08:00
Serialized more classes in gtsam and gtsam_unstable
2013-06-20 01:50:07 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Added SuccessiveLinearizationParams.ordering and BearingRangeFactor in matlab interface
2012-07-24 03:20:56 +08:00
};
Fixed wrapper
2015-07-13 13:49:04 +08:00
typedef gtsam::BearingRangeFactor<gtsam::Pose2, gtsam::Point2, gtsam::Rot2, double> BearingRangeFactor2D;
Made naming convention in wrapper uniform. 2D means Pose2 + Point2 3D means Pose3 + Point3
2019-01-01 00:19:46 +08:00
typedef gtsam::BearingRangeFactor<gtsam::Pose2, gtsam::Pose2, gtsam::Rot2, double> BearingRangeFactorPose2;
Added SuccessiveLinearizationParams.ordering and BearingRangeFactor in matlab interface
2012-07-24 03:20:56 +08:00
Simplified include handling in wrap: no more default includes, includes are not associated with a class or a namespace.
2012-07-18 02:30:02 +08:00
#include <gtsam/slam/ProjectionFactor.h>
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
template<POSE, LANDMARK, CALIBRATION>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class GenericProjectionFactor : gtsam::NoiseModelFactor {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
GenericProjectionFactor(const gtsam::Point2& measured, const gtsam::noiseModel::Base* noiseModel,
size_t poseKey, size_t pointKey, const CALIBRATION* k);
Overload for insertProjectionFactors in matlab utilities
2012-12-18 06:30:54 +08:00
GenericProjectionFactor(const gtsam::Point2& measured, const gtsam::noiseModel::Base* noiseModel,
size_t poseKey, size_t pointKey, const CALIBRATION* k, const POSE& body_P_sensor);
Added flags in ProjectionFactor to allow optional verbosity in printing during Cheirality exceptions, as well as optional re-throwing of the exception. By default, Cheriality exceptions will be silent.
2013-02-22 05:21:07 +08:00
GenericProjectionFactor(const gtsam::Point2& measured, const gtsam::noiseModel::Base* noiseModel,
size_t poseKey, size_t pointKey, const CALIBRATION* k, bool throwCheirality, bool verboseCheirality);
GenericProjectionFactor(const gtsam::Point2& measured, const gtsam::noiseModel::Base* noiseModel,
size_t poseKey, size_t pointKey, const CALIBRATION* k, bool throwCheirality, bool verboseCheirality,
const POSE& body_P_sensor);
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::Point2 measured() const;
CALIBRATION* calibration() const;
Added flags in ProjectionFactor to allow optional verbosity in printing during Cheirality exceptions, as well as optional re-throwing of the exception. By default, Cheriality exceptions will be silent.
2013-02-22 05:21:07 +08:00
bool verboseCheirality() const;
bool throwCheirality() const;
Serialized more classes in gtsam and gtsam_unstable
2013-06-20 01:50:07 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
};
typedef gtsam::GenericProjectionFactor<gtsam::Pose3, gtsam::Point3, gtsam::Cal3_S2> GenericProjectionFactorCal3_S2;
Wrapped Cal3DS2
2013-02-16 01:27:38 +08:00
typedef gtsam::GenericProjectionFactor<gtsam::Pose3, gtsam::Point3, gtsam::Cal3DS2> GenericProjectionFactorCal3DS2;
Wrapped GeneralSFMFactor and added placeholders for Cal3DS2 once it has a 'calibrate' function
2012-07-24 05:27:42 +08:00
#include <gtsam/slam/GeneralSFMFactor.h>
template<CAMERA, LANDMARK>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class GeneralSFMFactor : gtsam::NoiseModelFactor {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
GeneralSFMFactor(const gtsam::Point2& measured, const gtsam::noiseModel::Base* model, size_t cameraKey, size_t landmarkKey);
gtsam::Point2 measured() const;
Wrapped GeneralSFMFactor and added placeholders for Cal3DS2 once it has a 'calibrate' function
2012-07-24 05:27:42 +08:00
};
replaced/appended all calls to SimpleCamera with PinholeCameraCal3_S2
2020-02-22 08:42:55 +08:00
typedef gtsam::GeneralSFMFactor<gtsam::PinholeCameraCal3_S2, gtsam::Point3> GeneralSFMFactorCal3_S2;
remove some wrapping terms to fix toolbox compile
2018-06-19 13:00:20 +08:00
// due to lack of jacobians of Cal3DS2_Base::calibrate, GeneralSFMFactor does not apply to Cal3DS2
//typedef gtsam::GeneralSFMFactor<gtsam::PinholeCameraCal3DS2, gtsam::Point3> GeneralSFMFactorCal3DS2;
Wrapped GeneralSFMFactor and added placeholders for Cal3DS2 once it has a 'calibrate' function
2012-07-24 05:27:42 +08:00
template<CALIBRATION = {gtsam::Cal3_S2}>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class GeneralSFMFactor2 : gtsam::NoiseModelFactor {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
GeneralSFMFactor2(const gtsam::Point2& measured, const gtsam::noiseModel::Base* model, size_t poseKey, size_t landmarkKey, size_t calibKey);
gtsam::Point2 measured() const;
Serialized more classes in gtsam and gtsam_unstable
2013-06-20 01:50:07 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Wrapped GeneralSFMFactor and added placeholders for Cal3DS2 once it has a 'calibrate' function
2012-07-24 05:27:42 +08:00
};
Wrapped Cal3DS2, RangeFactor, BearingFactor, and GenericProjectionFactor
2012-07-12 10:11:32 +08:00
Fixed MATLAB wrapping of smart factor
2015-06-21 02:49:44 +08:00
#include <gtsam/slam/SmartProjectionFactor.h>
class SmartProjectionParams {
SmartProjectionParams();
// TODO(frank): make these work:
// void setLinearizationMode(LinearizationMode linMode);
// void setDegeneracyMode(DegeneracyMode degMode);
void setRankTolerance(double rankTol);
void setEnableEPI(bool enableEPI);
void setLandmarkDistanceThreshold(bool landmarkDistanceThreshold);
void setDynamicOutlierRejectionThreshold(bool dynOutRejectionThreshold);
};
Move Smart Projection Factor wrapper to stable
2014-06-21 01:41:51 +08:00
#include <gtsam/slam/SmartProjectionPoseFactor.h>
Got rid of template parameters POSE (which was a fiction) and Z (which is now derived as CAMERA::Measurement).
2015-02-19 19:27:40 +08:00
template<CALIBRATION>
Fixed MATLAB wrapping of smart factor
2015-06-21 02:49:44 +08:00
virtual class SmartProjectionPoseFactor: gtsam::NonlinearFactor {
Move Smart Projection Factor wrapper to stable
2014-06-21 01:41:51 +08:00
Fix examples and Matlab wrapper
2015-08-27 01:25:12 +08:00
SmartProjectionPoseFactor(const gtsam::noiseModel::Base* noise,
const CALIBRATION* K);
SmartProjectionPoseFactor(const gtsam::noiseModel::Base* noise,
const CALIBRATION* K,
Fixed MATLAB wrapping of smart factor
2015-06-21 02:49:44 +08:00
const gtsam::Pose3& body_P_sensor);
deprecated SmartProjectionFactor constructor with offset
2019-08-08 23:53:05 +08:00
SmartProjectionPoseFactor(const gtsam::noiseModel::Base* noise,
const CALIBRATION* K,
const gtsam::SmartProjectionParams& params);
Fix examples and Matlab wrapper
2015-08-27 01:25:12 +08:00
SmartProjectionPoseFactor(const gtsam::noiseModel::Base* noise,
const CALIBRATION* K,
Fixed MATLAB wrapping of smart factor
2015-06-21 02:49:44 +08:00
const gtsam::Pose3& body_P_sensor,
const gtsam::SmartProjectionParams& params);
Move Smart Projection Factor wrapper to stable
2014-06-21 01:41:51 +08:00
Fix examples and Matlab wrapper
2015-08-27 01:25:12 +08:00
void add(const gtsam::Point2& measured_i, size_t poseKey_i);
Move Smart Projection Factor wrapper to stable
2014-06-21 01:41:51 +08:00
// enabling serialization functionality
//void serialize() const;
};
Got rid of template parameters POSE (which was a fiction) and Z (which is now derived as CAMERA::Measurement).
2015-02-19 19:27:40 +08:00
typedef gtsam::SmartProjectionPoseFactor<gtsam::Cal3_S2> SmartProjectionPose3Factor;
Move Smart Projection Factor wrapper to stable
2014-06-21 01:41:51 +08:00
Wrapped GenericStereoFactor
2012-07-24 22:23:36 +08:00
#include <gtsam/slam/StereoFactor.h>
template<POSE, LANDMARK>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class GenericStereoFactor : gtsam::NoiseModelFactor {
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
GenericStereoFactor(const gtsam::StereoPoint2& measured, const gtsam::noiseModel::Base* noiseModel,
size_t poseKey, size_t landmarkKey, const gtsam::Cal3_S2Stereo* K);
gtsam::StereoPoint2 measured() const;
gtsam::Cal3_S2Stereo* calibration() const;
Serialized more classes in gtsam and gtsam_unstable
2013-06-20 01:50:07 +08:00
// enabling serialization functionality
Added cmake flag to disable serialization for wrapped objects directly, rather than outright disabling serialization. By default GTSAM_WRAP_SERIALIZATION is on, turn it off to ignore serialization flags in gtsam.h
2013-10-24 22:38:04 +08:00
void serialize() const;
Wrapped GenericStereoFactor
2012-07-24 22:23:36 +08:00
};
typedef gtsam::GenericStereoFactor<gtsam::Pose3, gtsam::Point3> GenericStereoFactor3D;
Updated matlab wrapping for moved factors
2013-05-01 01:50:48 +08:00
#include <gtsam/slam/PoseTranslationPrior.h>
template<POSE>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class PoseTranslationPrior : gtsam::NoiseModelFactor {
Updated matlab wrapping for moved factors
2013-05-01 01:50:48 +08:00
PoseTranslationPrior(size_t key, const POSE& pose_z, const gtsam::noiseModel::Base* noiseModel);
};
typedef gtsam::PoseTranslationPrior<gtsam::Pose2> PoseTranslationPrior2D;
typedef gtsam::PoseTranslationPrior<gtsam::Pose3> PoseTranslationPrior3D;
#include <gtsam/slam/PoseRotationPrior.h>
template<POSE>
Wrapped copy constructor for Pose2, lots of routines for GaussianBayesTree, and made all NL factors descend from noiseModelFactor, so we get unwhitenedError etc by inheritance...
2013-06-21 03:44:50 +08:00
virtual class PoseRotationPrior : gtsam::NoiseModelFactor {
Updated matlab wrapping for moved factors
2013-05-01 01:50:48 +08:00
PoseRotationPrior(size_t key, const POSE& pose_z, const gtsam::noiseModel::Base* noiseModel);
};
typedef gtsam::PoseRotationPrior<gtsam::Pose2> PoseRotationPrior2D;
typedef gtsam::PoseRotationPrior<gtsam::Pose3> PoseRotationPrior3D;
MATLAB wrapping and Monocular VO example
2013-12-18 00:18:31 +08:00
#include <gtsam/slam/EssentialMatrixFactor.h>
virtual class EssentialMatrixFactor : gtsam::NoiseModelFactor {
EssentialMatrixFactor(size_t key, const gtsam::Point2& pA, const gtsam::Point2& pB,
const gtsam::noiseModel::Base* noiseModel);
};
load2D wrapped, but pair argument does not work?
2012-07-26 09:40:25 +08:00
#include <gtsam/slam/dataset.h>
follow Google style guide naming convention for Sfm related data structs
2020-03-07 06:59:09 +08:00
class SfmTrack {
added more function to retrieve SfM_data and wrapped them
2020-03-04 10:41:44 +08:00
size_t number_measurements() const;
pair<size_t, gtsam::Point2> measurement(size_t idx) const;
follow Google style guide naming convention for Sfm related data structs
2020-03-07 06:59:09 +08:00
pair<size_t, size_t> siftIndex(size_t idx) const;
added more function to retrieve SfM_data and wrapped them
2020-03-04 10:41:44 +08:00
};
follow Google style guide naming convention for Sfm related data structs
2020-03-07 06:59:09 +08:00
class SfmData {
wrap SfM_data struct
2020-02-22 07:36:50 +08:00
size_t number_cameras() const;
size_t number_tracks() const;
added more function to retrieve SfM_data and wrapped them
2020-03-04 10:41:44 +08:00
//TODO(Varun) Need to fix issue #237 first before this can work
// gtsam::PinholeCamera<gtsam::Cal3Bundler> camera(size_t idx) const;
follow Google style guide naming convention for Sfm related data structs
2020-03-07 06:59:09 +08:00
gtsam::SfmTrack track(size_t idx) const;
wrap SfM_data struct
2020-02-22 07:36:50 +08:00
};
Adding wrapper for Pose3 for reading g2o files and examples for Pose2 and Pose3 slam using g2o file
2019-01-19 11:05:57 +08:00
string findExampleDataFile(string name);
Finished denamespacing and reorganizing matlab code
2012-07-28 03:02:11 +08:00
pair<gtsam::NonlinearFactorGraph*, gtsam::Values*> load2D(string filename,
load2D wrapped, but pair argument does not work?
2012-07-26 09:40:25 +08:00
gtsam::noiseModel::Diagonal* model, int maxID, bool addNoise, bool smart);
Wrapped default-argument versions of load2D
2012-07-31 02:34:47 +08:00
pair<gtsam::NonlinearFactorGraph*, gtsam::Values*> load2D(string filename,
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::noiseModel::Diagonal* model, int maxID, bool addNoise);
Wrapped default-argument versions of load2D
2012-07-31 02:34:47 +08:00
pair<gtsam::NonlinearFactorGraph*, gtsam::Values*> load2D(string filename,
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::noiseModel::Diagonal* model, int maxID);
Wrapped default-argument versions of load2D
2012-07-31 02:34:47 +08:00
pair<gtsam::NonlinearFactorGraph*, gtsam::Values*> load2D(string filename,
changed tabs to spaces for consistent indentation in all of GTSAM
2012-10-02 22:40:07 +08:00
gtsam::noiseModel::Diagonal* model);
Added wrapped version of load2D that doesn't override noisemodel
2013-12-06 03:56:46 +08:00
pair<gtsam::NonlinearFactorGraph*, gtsam::Values*> load2D(string filename);
Added load2D_robust function to allow robust noise models when loading datasets.
2013-05-21 05:46:30 +08:00
pair<gtsam::NonlinearFactorGraph*, gtsam::Values*> load2D_robust(string filename,
gtsam::noiseModel::Base* model);
Sanitized G2o I/O interface to conform to what we had before. No sense in having many different styles, and this works better for MATLAB (now wrapped, as well). BAL reading/writing should be similarly cleaned up.
2014-06-01 23:46:23 +08:00
void save2D(const gtsam::NonlinearFactorGraph& graph,
const gtsam::Values& config, gtsam::noiseModel::Diagonal* model,
string filename);
Wrapped parse3DFactors
2019-03-14 13:25:06 +08:00
// std::vector<gtsam::BetweenFactor<Pose3>::shared_ptr>
class BetweenFactorPose3s
{
size_t size() const;
gtsam::BetweenFactorPose3* at(size_t i) const;
};
Wrapped
2019-03-20 03:47:51 +08:00
#include <gtsam/slam/InitializePose3.h>
Switched to struct with static methods as apparently global methods in namespaces are not wrapped.
2019-03-20 05:04:31 +08:00
class InitializePose3 {
static gtsam::Values computeOrientationsChordal(
const gtsam::NonlinearFactorGraph& pose3Graph);
static gtsam::Values computeOrientationsGradient(
const gtsam::NonlinearFactorGraph& pose3Graph,
const gtsam::Values& givenGuess, size_t maxIter, const bool setRefFrame);
static gtsam::Values computeOrientationsGradient(
const gtsam::NonlinearFactorGraph& pose3Graph,
const gtsam::Values& givenGuess);
static gtsam::NonlinearFactorGraph buildPose3graph(
const gtsam::NonlinearFactorGraph& graph);
static gtsam::Values initializeOrientations(
const gtsam::NonlinearFactorGraph& graph);
static gtsam::Values initialize(const gtsam::NonlinearFactorGraph& graph,
const gtsam::Values& givenGuess,
bool useGradient);
static gtsam::Values initialize(const gtsam::NonlinearFactorGraph& graph);
};
Wrapped
2019-03-20 03:47:51 +08:00
Wrapped parse3DFactors
2019-03-14 13:25:06 +08:00
gtsam::BetweenFactorPose3s parse3DFactors(string filename);
pair<gtsam::NonlinearFactorGraph*, gtsam::Values*> load3D(string filename);
Sanitized G2o I/O interface to conform to what we had before. No sense in having many different styles, and this works better for MATLAB (now wrapped, as well). BAL reading/writing should be similarly cleaned up.
2014-06-01 23:46:23 +08:00
pair<gtsam::NonlinearFactorGraph*, gtsam::Values*> readG2o(string filename);
Adding wrapper for Pose3 for reading g2o files and examples for Pose2 and Pose3 slam using g2o file
2019-01-19 11:05:57 +08:00
pair<gtsam::NonlinearFactorGraph*, gtsam::Values*> readG2o(string filename, bool is3D);
Sanitized G2o I/O interface to conform to what we had before. No sense in having many different styles, and this works better for MATLAB (now wrapped, as well). BAL reading/writing should be similarly cleaned up.
2014-06-01 23:46:23 +08:00
void writeG2o(const gtsam::NonlinearFactorGraph& graph,
const gtsam::Values& estimate, string filename);
Added matlab.h, a temporary file holding special namespace functions. These need to be reviewed and a permanent home found.
2012-07-30 23:40:58 +08:00
Wrapped SO(3), SO(4) and new factor, and added SO(4) tests in python
2019-04-17 12:07:38 +08:00
#include <gtsam/slam/KarcherMeanFactor-inl.h>
template<T = {gtsam::Point2, gtsam::Rot2, gtsam::Pose2, gtsam::Point3, gtsam::SO3, gtsam::SO4, gtsam::Rot3, gtsam::Pose3}>
virtual class KarcherMeanFactor : gtsam::NonlinearFactor {
KarcherMeanFactor(const gtsam::KeyVector& keys);
};
Brought some relevant changes from aspn-imu-factor branch (is correct this time)
2013-08-03 00:04:17 +08:00
//*************************************************************************
// Navigation
//*************************************************************************
namespace imuBias {
#include <gtsam/navigation/ImuBias.h>
matlab wrapper code needs to be updated since lieXXX are not used anymore
2014-11-07 23:41:43 +08:00
class ConstantBias {
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
// Constructors
Brought some relevant changes from aspn-imu-factor branch (is correct this time)
2013-08-03 00:04:17 +08:00
ConstantBias();
ConstantBias(Vector biasAcc, Vector biasGyro);
// Testable
void print(string s) const;
bool equals(const gtsam::imuBias::ConstantBias& expected, double tol) const;
// Group
static gtsam::imuBias::ConstantBias identity();
gtsam::imuBias::ConstantBias inverse() const;
gtsam::imuBias::ConstantBias compose(const gtsam::imuBias::ConstantBias& b) const;
gtsam::imuBias::ConstantBias between(const gtsam::imuBias::ConstantBias& b) const;
// Manifold
gtsam::imuBias::ConstantBias retract(Vector v) const;
Vector localCoordinates(const gtsam::imuBias::ConstantBias& b) const;
// Lie Group
static gtsam::imuBias::ConstantBias Expmap(Vector v);
static Vector Logmap(const gtsam::imuBias::ConstantBias& b);
// Standard Interface
Vector vector() const;
Vector accelerometer() const;
Vector gyroscope() const;
Vector correctAccelerometer(Vector measurement) const;
Vector correctGyroscope(Vector measurement) const;
};
}///\namespace imuBias
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
#include <gtsam/navigation/NavState.h>
class NavState {
// Constructors
NavState();
NavState(const gtsam::Rot3& R, const gtsam::Point3& t, Vector v);
NavState(const gtsam::Pose3& pose, Vector v);
Moved ImuFactor and CombinedImuFactor into main gtsam, and moved InertialNavFactor family into gtsam_unstable.
2013-08-14 05:04:31 +08:00
// Testable
void print(string s) const;
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
bool equals(const gtsam::NavState& expected, double tol) const;
// Access
gtsam::Rot3 attitude() const;
gtsam::Point3 position() const;
Vector velocity() const;
gtsam::Pose3 pose() const;
};
Added setters and getters for MATLAB wrapper
2016-04-11 01:56:36 +08:00
#include <gtsam/navigation/PreintegratedRotation.h>
virtual class PreintegratedRotationParams {
PreintegratedRotationParams();
Add named constructors for PreintegrationParams
2018-10-14 22:59:51 +08:00
// Testable
void print(string s) const;
bool equals(const gtsam::PreintegratedRotationParams& expected, double tol);
Added setters and getters for MATLAB wrapper
2016-04-11 01:56:36 +08:00
void setGyroscopeCovariance(Matrix cov);
void setOmegaCoriolis(Vector omega);
void setBodyPSensor(const gtsam::Pose3& pose);
Matrix getGyroscopeCovariance() const;
// TODO(frank): allow optional
Added Scenario class
2018-10-14 22:34:02 +08:00
// boost::optional<Vector> getOmegaCoriolis() const;
Added setters and getters for MATLAB wrapper
2016-04-11 01:56:36 +08:00
// boost::optional<Pose3> getBodyPSensor() const;
};
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
#include <gtsam/navigation/PreintegrationParams.h>
Added setters and getters for MATLAB wrapper
2016-04-11 01:56:36 +08:00
virtual class PreintegrationParams : gtsam::PreintegratedRotationParams {
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
PreintegrationParams(Vector n_gravity);
Add named constructors for PreintegrationParams
2018-10-14 22:59:51 +08:00
static gtsam::PreintegrationParams* MakeSharedD(double g);
static gtsam::PreintegrationParams* MakeSharedU(double g);
static gtsam::PreintegrationParams* MakeSharedD(); // default g = 9.81
static gtsam::PreintegrationParams* MakeSharedU(); // default g = 9.81
// Testable
void print(string s) const;
bool equals(const gtsam::PreintegrationParams& expected, double tol);
Added setters and getters for MATLAB wrapper
2016-04-11 01:56:36 +08:00
void setAccelerometerCovariance(Matrix cov);
void setIntegrationCovariance(Matrix cov);
void setUse2ndOrderCoriolis(bool flag);
Matrix getAccelerometerCovariance() const;
Matrix getIntegrationCovariance() const;
bool getUse2ndOrderCoriolis() const;
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
};
#include <gtsam/navigation/ImuFactor.h>
fix matlab compile issue, by removing abstract class PreintegrationBase from wrapper declearation
2016-06-03 09:04:52 +08:00
class PreintegratedImuMeasurements {
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
// Constructors
PreintegratedImuMeasurements(const gtsam::PreintegrationParams* params);
PreintegratedImuMeasurements(const gtsam::PreintegrationParams* params,
const gtsam::imuBias::ConstantBias& bias);
// Testable
void print(string s) const;
bool equals(const gtsam::PreintegratedImuMeasurements& expected, double tol);
// Standard Interface
void integrateMeasurement(Vector measuredAcc, Vector measuredOmega,
double deltaT);
void resetIntegration();
Matrix preintMeasCov() const;
fix matlab compile issue, by removing abstract class PreintegrationBase from wrapper declearation
2016-06-03 09:04:52 +08:00
double deltaTij() const;
gtsam::Rot3 deltaRij() const;
Vector deltaPij() const;
Vector deltaVij() const;
Vector biasHatVector() const;
gtsam::NavState predict(const gtsam::NavState& state_i,
const gtsam::imuBias::ConstantBias& bias) const;
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
};
virtual class ImuFactor: gtsam::NonlinearFactor {
ImuFactor(size_t pose_i, size_t vel_i, size_t pose_j, size_t vel_j,
size_t bias,
const gtsam::PreintegratedImuMeasurements& preintegratedMeasurements);
Moved ImuFactor and CombinedImuFactor into main gtsam, and moved InertialNavFactor family into gtsam_unstable.
2013-08-14 05:04:31 +08:00
// Standard Interface
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
gtsam::PreintegratedImuMeasurements preintegratedMeasurements() const;
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
Vector evaluateError(const gtsam::Pose3& pose_i, Vector vel_i,
const gtsam::Pose3& pose_j, Vector vel_j,
const gtsam::imuBias::ConstantBias& bias);
Added matlab support for AHRSFactor.
2014-07-15 12:14:13 +08:00
};
Moved ImuFactor and CombinedImuFactor into main gtsam, and moved InertialNavFactor family into gtsam_unstable.
2013-08-14 05:04:31 +08:00
#include <gtsam/navigation/CombinedImuFactor.h>
Fix python wrappers for BetweenFactorVector and PreintegratedCombinedMeasurements and added Vector type to the BetweenFactor generation Created PreintegrationCombinedParams to add constructor for PreintegratedCombinedMeasurements
2019-10-18 22:55:02 +08:00
virtual class PreintegrationCombinedParams : gtsam::PreintegrationParams {
PreintegrationCombinedParams(Vector n_gravity);
static gtsam::PreintegrationCombinedParams* MakeSharedD(double g);
static gtsam::PreintegrationCombinedParams* MakeSharedU(double g);
static gtsam::PreintegrationCombinedParams* MakeSharedD(); // default g = 9.81
static gtsam::PreintegrationCombinedParams* MakeSharedU(); // default g = 9.81
// Testable
void print(string s) const;
bool equals(const gtsam::PreintegrationCombinedParams& expected, double tol);
void setBiasAccCovariance(Matrix cov);
void setBiasOmegaCovariance(Matrix cov);
void setBiasAccOmegaInt(Matrix cov);
Matrix getBiasAccCovariance() const ;
Matrix getBiasOmegaCovariance() const ;
Matrix getBiasAccOmegaInt() const;
};
fix matlab compile issue, by removing abstract class PreintegrationBase from wrapper declearation
2016-06-03 09:04:52 +08:00
class PreintegratedCombinedMeasurements {
Fix python wrappers for BetweenFactorVector and PreintegratedCombinedMeasurements and added Vector type to the BetweenFactor generation Created PreintegrationCombinedParams to add constructor for PreintegratedCombinedMeasurements
2019-10-18 22:55:02 +08:00
// Constructors
PreintegratedCombinedMeasurements(const gtsam::PreintegrationCombinedParams* params);
PreintegratedCombinedMeasurements(const gtsam::PreintegrationCombinedParams* params,
const gtsam::imuBias::ConstantBias& bias);
Moved ImuFactor and CombinedImuFactor into main gtsam, and moved InertialNavFactor family into gtsam_unstable.
2013-08-14 05:04:31 +08:00
// Testable
void print(string s) const;
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
bool equals(const gtsam::PreintegratedCombinedMeasurements& expected,
double tol);
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
// Standard Interface
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
void integrateMeasurement(Vector measuredAcc, Vector measuredOmega,
double deltaT);
void resetIntegration();
Matrix preintMeasCov() const;
fix matlab compile issue, by removing abstract class PreintegrationBase from wrapper declearation
2016-06-03 09:04:52 +08:00
double deltaTij() const;
gtsam::Rot3 deltaRij() const;
Vector deltaPij() const;
Vector deltaVij() const;
Vector biasHatVector() const;
gtsam::NavState predict(const gtsam::NavState& state_i,
const gtsam::imuBias::ConstantBias& bias) const;
Moved ImuFactor and CombinedImuFactor into main gtsam, and moved InertialNavFactor family into gtsam_unstable.
2013-08-14 05:04:31 +08:00
};
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
virtual class CombinedImuFactor: gtsam::NonlinearFactor {
CombinedImuFactor(size_t pose_i, size_t vel_i, size_t pose_j, size_t vel_j,
size_t bias_i, size_t bias_j,
const gtsam::PreintegratedCombinedMeasurements& CombinedPreintegratedMeasurements);
Moved ImuFactor and CombinedImuFactor into main gtsam, and moved InertialNavFactor family into gtsam_unstable.
2013-08-14 05:04:31 +08:00
// Standard Interface
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
gtsam::PreintegratedCombinedMeasurements preintegratedMeasurements() const;
Fixed MATLAB wrapper
2016-01-29 01:54:47 +08:00
Vector evaluateError(const gtsam::Pose3& pose_i, Vector vel_i,
const gtsam::Pose3& pose_j, Vector vel_j,
const gtsam::imuBias::ConstantBias& bias_i,
const gtsam::imuBias::ConstantBias& bias_j);
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
};
#include <gtsam/navigation/AHRSFactor.h>
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
class PreintegratedAhrsMeasurements {
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
// Standard Constructor
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
PreintegratedAhrsMeasurements(Vector bias, Matrix measuredOmegaCovariance);
PreintegratedAhrsMeasurements(const gtsam::PreintegratedAhrsMeasurements& rhs);
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
// Testable
void print(string s) const;
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
bool equals(const gtsam::PreintegratedAhrsMeasurements& expected, double tol);
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
// get Data
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
gtsam::Rot3 deltaRij() const;
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
double deltaTij() const;
Vector biasHat() const;
// Standard Interface
void integrateMeasurement(Vector measuredOmega, double deltaT);
void resetIntegration() ;
};
virtual class AHRSFactor : gtsam::NonlinearFactor {
AHRSFactor(size_t rot_i, size_t rot_j,size_t bias,
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
const gtsam::PreintegratedAhrsMeasurements& preintegratedMeasurements, Vector omegaCoriolis);
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
AHRSFactor(size_t rot_i, size_t rot_j, size_t bias,
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
const gtsam::PreintegratedAhrsMeasurements& preintegratedMeasurements, Vector omegaCoriolis,
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
const gtsam::Pose3& body_P_sensor);
// Standard Interface
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
gtsam::PreintegratedAhrsMeasurements preintegratedMeasurements() const;
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
Vector evaluateError(const gtsam::Rot3& rot_i, const gtsam::Rot3& rot_j,
Vector bias) const;
gtsam::Rot3 predict(const gtsam::Rot3& rot_i, Vector bias,
Fixed MATLAB wrapper (old-style interface still)
2015-07-19 14:11:27 +08:00
const gtsam::PreintegratedAhrsMeasurements& preintegratedMeasurements,
Cherry-picked imuFixed differences
2014-12-27 01:23:14 +08:00
Vector omegaCoriolis) const;
Moved ImuFactor and CombinedImuFactor into main gtsam, and moved InertialNavFactor family into gtsam_unstable.
2013-08-14 05:04:31 +08:00
};
Added matlab wrapper for Rot3AttitudeFactor. Added a couple of functions to access data from the class in Matlab
2014-07-19 04:46:58 +08:00
#include <gtsam/navigation/AttitudeFactor.h>
//virtual class AttitudeFactor : gtsam::NonlinearFactor {
// AttitudeFactor(const Unit3& nZ, const Unit3& bRef);
// AttitudeFactor();
//};
virtual class Rot3AttitudeFactor : gtsam::NonlinearFactor{
Rot3AttitudeFactor(size_t key, const gtsam::Unit3& nZ, const gtsam::noiseModel::Diagonal* model,
const gtsam::Unit3& bRef);
Rot3AttitudeFactor(size_t key, const gtsam::Unit3& nZ, const gtsam::noiseModel::Diagonal* model);
Rot3AttitudeFactor();
void print(string s) const;
bool equals(const gtsam::NonlinearFactor& expected, double tol) const;
gtsam::Unit3 nZ() const;
gtsam::Unit3 bRef() const;
};
Successful wrap of Scenario
2018-10-17 05:01:47 +08:00
virtual class Pose3AttitudeFactor : gtsam::NonlinearFactor {
Pose3AttitudeFactor(size_t key, const gtsam::Unit3& nZ,
const gtsam::noiseModel::Diagonal* model,
const gtsam::Unit3& bRef);
Pose3AttitudeFactor(size_t key, const gtsam::Unit3& nZ,
const gtsam::noiseModel::Diagonal* model);
Fixed Dynamics Factor and added debug cout statements to help fix indeterminent linear system exception
2014-10-15 06:08:26 +08:00
Pose3AttitudeFactor();
void print(string s) const;
bool equals(const gtsam::NonlinearFactor& expected, double tol) const;
gtsam::Unit3 nZ() const;
gtsam::Unit3 bRef() const;
Moved ImuFactor and CombinedImuFactor into main gtsam, and moved InertialNavFactor family into gtsam_unstable.
2013-08-14 05:04:31 +08:00
};
expose GPSFactor in python wrapper, and add example for it
2019-10-20 05:15:56 +08:00
#include <gtsam/navigation/GPSFactor.h>
virtual class GPSFactor : gtsam::NonlinearFactor{
GPSFactor(size_t key, const gtsam::Point3& gpsIn,
const gtsam::noiseModel::Base* model);
// Testable
void print(string s) const;
bool equals(const gtsam::GPSFactor& expected, double tol);
// Standard Interface
gtsam::Point3 measurementIn() const;
};
virtual class GPSFactor2 : gtsam::NonlinearFactor {
GPSFactor2(size_t key, const gtsam::Point3& gpsIn,
const gtsam::noiseModel::Base* model);
// Testable
void print(string s) const;
bool equals(const gtsam::GPSFactor2& expected, double tol);
// Standard Interface
gtsam::Point3 measurementIn() const;
};
Added Scenario class
2018-10-14 22:34:02 +08:00
#include <gtsam/navigation/Scenario.h>
Successful wrap of Scenario
2018-10-17 05:01:47 +08:00
virtual class Scenario {
Added Scenario class
2018-10-14 22:34:02 +08:00
gtsam::Pose3 pose(double t) const;
Vector omega_b(double t) const;
Vector velocity_n(double t) const;
Vector acceleration_n(double t) const;
Successful wrap of Scenario
2018-10-17 05:01:47 +08:00
gtsam::Rot3 rotation(double t) const;
gtsam::NavState navState(double t) const;
Vector velocity_b(double t) const;
Vector acceleration_b(double t) const;
};
virtual class ConstantTwistScenario : gtsam::Scenario {
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
ConstantTwistScenario(Vector w, Vector v);
ConstantTwistScenario(Vector w, Vector v,
Added gtsam:: qualifier
2018-10-31 06:32:37 +08:00
const gtsam::Pose3& nTb0);
Added Scenario class
2018-10-14 22:34:02 +08:00
};
virtual class AcceleratingScenario : gtsam::Scenario {
AcceleratingScenario(const gtsam::Rot3& nRb, const gtsam::Point3& p0,
fix "const Vector&" in gtsam.h
2018-10-17 18:01:14 +08:00
Vector v0, Vector a_n,
Vector omega_b);
Added Scenario class
2018-10-14 22:34:02 +08:00
};
Wrap ScenarioRunner
2019-05-18 10:10:48 +08:00
#include <gtsam/navigation/ScenarioRunner.h>
class ScenarioRunner {
ScenarioRunner(const gtsam::Scenario& scenario,
const gtsam::PreintegrationParams* p,
double imuSampleTime,
const gtsam::imuBias::ConstantBias& bias);
Vector gravity_n() const;
Vector actualAngularVelocity(double t) const;
Vector actualSpecificForce(double t) const;
Vector measuredAngularVelocity(double t) const;
Vector measuredSpecificForce(double t) const;
double imuSampleTime() const;
gtsam::PreintegratedImuMeasurements integrate(
double T, const gtsam::imuBias::ConstantBias& estimatedBias,
bool corrupted) const;
gtsam::NavState predict(
const gtsam::PreintegratedImuMeasurements& pim,
const gtsam::imuBias::ConstantBias& estimatedBias) const;
Matrix estimateCovariance(
double T, size_t N,
const gtsam::imuBias::ConstantBias& estimatedBias) const;
Matrix estimateNoiseCovariance(size_t N) const;
};
Added matlab.h, a temporary file holding special namespace functions. These need to be reviewed and a permanent home found.
2012-07-30 23:40:58 +08:00
//*************************************************************************
// Utilities
//*************************************************************************
namespace utilities {
replace matlab.h in gtsam.h for matlab wrapper by its new file nonlinear/utilities.h
2016-11-25 08:26:11 +08:00
#include <gtsam/nonlinear/utilities.h>
New routines to create Key collections
2014-05-25 23:15:17 +08:00
gtsam::KeyList createKeyList(Vector I);
gtsam::KeyList createKeyList(string s, Vector I);
gtsam::KeyVector createKeyVector(Vector I);
gtsam::KeyVector createKeyVector(string s, Vector I);
gtsam::KeySet createKeySet(Vector I);
gtsam::KeySet createKeySet(string s, Vector I);
Added matlab.h, a temporary file holding special namespace functions. These need to be reviewed and a permanent home found.
2012-07-30 23:40:58 +08:00
Matrix extractPoint2(const gtsam::Values& values);
Matrix extractPoint3(const gtsam::Values& values);
Matrix extractPose2(const gtsam::Values& values);
wrapped allPose3s, pop methods in KeyList
2012-11-18 03:24:39 +08:00
gtsam::Values allPose3s(gtsam::Values& values);
Added matlab.h, a temporary file holding special namespace functions. These need to be reviewed and a permanent home found.
2012-07-30 23:40:58 +08:00
Matrix extractPose3(const gtsam::Values& values);
void perturbPoint2(gtsam::Values& values, double sigma, int seed);
New perturbPose2 utility
2014-05-06 12:23:20 +08:00
void perturbPose2 (gtsam::Values& values, double sigmaT, double sigmaR, int seed);
Added matlab.h, a temporary file holding special namespace functions. These need to be reviewed and a permanent home found.
2012-07-30 23:40:58 +08:00
void perturbPoint3(gtsam::Values& values, double sigma, int seed);
replaced/appended all calls to SimpleCamera with PinholeCameraCal3_S2
2020-02-22 08:42:55 +08:00
void insertBackprojections(gtsam::Values& values, const gtsam::PinholeCameraCal3_S2& c, Vector J, Matrix Z, double depth);
Added a C++ function for matlab to insert multiple projection factors from a single frame.
2012-08-06 07:52:47 +08:00
void insertProjectionFactors(gtsam::NonlinearFactorGraph& graph, size_t i, Vector J, Matrix Z, const gtsam::noiseModel::Base* model, const gtsam::Cal3_S2* K);
Overload for insertProjectionFactors in matlab utilities
2012-12-18 06:30:54 +08:00
void insertProjectionFactors(gtsam::NonlinearFactorGraph& graph, size_t i, Vector J, Matrix Z, const gtsam::noiseModel::Base* model, const gtsam::Cal3_S2* K, const gtsam::Pose3& body_P_sensor);
Added matlab.h, a temporary file holding special namespace functions. These need to be reviewed and a permanent home found.
2012-07-30 23:40:58 +08:00
Matrix reprojectionErrors(const gtsam::NonlinearFactorGraph& graph, const gtsam::Values& values);
utilities.localToWorld
2014-05-27 12:42:03 +08:00
gtsam::Values localToWorld(const gtsam::Values& local, const gtsam::Pose2& base);
gtsam::Values localToWorld(const gtsam::Values& local, const gtsam::Pose2& base, const gtsam::KeyVector& keys);
Added matlab.h, a temporary file holding special namespace functions. These need to be reviewed and a permanent home found.
2012-07-30 23:40:58 +08:00
} //\namespace utilities
redirect stdcout to a stringstream so Python __str__() can properly return a string after calling the c++ print function This is to avoid a printing issue in some Python's IDE when __str__() is called to update objects' values in Debug mode.
2017-07-26 04:32:26 +08:00
#include <gtsam/nonlinear/utilities.h>
class RedirectCout {
RedirectCout();
string str();
};
Finished denamespacing and reorganizing matlab code
2012-07-28 03:02:11 +08:00
}