Main MRPT website > C++ reference for MRPT 1.5.3
Namespaces | Classes | Typedefs | Functions | Variables
Sophus Namespace Reference

Namespaces

 details
 
 interp_details
 

Classes

struct  Constants
 
struct  Constants< float >
 
struct  nullopt_t
 
class  optional
 
class  RxSO3
 
class  RxSO3Base
 
class  SE2
 
class  SE2Base
 
class  SE3
 
class  SE3Base
 
class  Sim3
 
class  Sim3Base
 
class  SO2
 
class  SO2Base
 
class  SO3
 
class  SO3Base
 

Typedefs

template<bool B, class T = void>
using enable_if_t = typename std::enable_if< B, T >::type
 
using RxSO3d = RxSO3< double >
 
using RxSO3f = RxSO3< float >
 
using SE2d = SE2< double >
 
using SE2f = SE2< float >
 
using SE3d = SE3< double >
 
using SE3f = SE3< float >
 
using Sim3d = Sim3< double >
 
using Sim3f = Sim3< float >
 
using SO2d = SO2< double >
 
using SO2f = SO2< float >
 
using SO3d = SO3< double >
 
using SO3f = SO3< float >
 
template<class Scalar , int M, int Options = 0>
using Vector = Eigen::Matrix< Scalar, M, 1, Options >
 
template<class Scalar , int Options = 0>
using Vector2 = Vector< Scalar, 2, Options >
 
using Vector2f = Vector2< float >
 
using Vector2d = Vector2< double >
 
template<class Scalar , int Options = 0>
using Vector3 = Vector< Scalar, 3, Options >
 
using Vector3f = Vector3< float >
 
using Vector3d = Vector3< double >
 
template<class Scalar >
using Vector4 = Vector< Scalar, 4 >
 
using Vector4f = Vector4< float >
 
using Vector4d = Vector4< double >
 
template<class Scalar >
using Vector6 = Vector< Scalar, 6 >
 
using Vector6f = Vector6< float >
 
using Vector6d = Vector6< double >
 
template<class Scalar >
using Vector7 = Vector< Scalar, 7 >
 
using Vector7f = Vector7< float >
 
using Vector7d = Vector7< double >
 
template<class Scalar , int M, int N>
using Matrix = Eigen::Matrix< Scalar, M, N >
 
template<class Scalar >
using Matrix2 = Matrix< Scalar, 2, 2 >
 
using Matrix2f = Matrix2< float >
 
using Matrix2d = Matrix2< double >
 
template<class Scalar >
using Matrix3 = Matrix< Scalar, 3, 3 >
 
using Matrix3f = Matrix3< float >
 
using Matrix3d = Matrix3< double >
 
template<class Scalar >
using Matrix4 = Matrix< Scalar, 4, 4 >
 
using Matrix4f = Matrix4< float >
 
using Matrix4d = Matrix4< double >
 
template<class Scalar >
using Matrix6 = Matrix< Scalar, 6, 6 >
 
using Matrix6f = Matrix6< float >
 
using Matrix6d = Matrix6< double >
 
template<class Scalar >
using Matrix7 = Matrix< Scalar, 7, 7 >
 
using Matrix7f = Matrix7< float >
 
using Matrix7d = Matrix7< double >
 
template<class T >
using Plane3 = Eigen::Hyperplane< T, 3 >
 
using Plane3d = Plane3< double >
 
using Plane3f = Plane3< float >
 
template<class T >
using Line2 = Eigen::Hyperplane< T, 2 >
 
using Line2d = Line2< double >
 
using Line2f = Line2< float >
 

Functions

template<class SequenceContainer >
optional< typename SequenceContainer::value_type > iterativeMean (SequenceContainer const &foo_Ts_bar, int max_num_iterations)
 
template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same< typename SequenceContainer::value_type, SO2< Scalar > >::value, optional< typename SequenceContainer::value_type > > average (SequenceContainer const &foo_Ts_bar)
 
template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same< typename SequenceContainer::value_type, SO3< Scalar > >::value, optional< typename SequenceContainer::value_type > > average (SequenceContainer const &foo_Ts_bar)
 
template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same< typename SequenceContainer::value_type, RxSO3< Scalar > >::value, optional< typename SequenceContainer::value_type > > average (SequenceContainer const &foo_Ts_bar)
 
template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same< typename SequenceContainer::value_type, SE2< Scalar > >::value, optional< typename SequenceContainer::value_type > > average (SequenceContainer const &foo_Ts_bar, int max_num_iterations=20)
 
template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same< typename SequenceContainer::value_type, SE3< Scalar > >::value, optional< typename SequenceContainer::value_type > > average (SequenceContainer const &foo_Ts_bar, int max_num_iterations=20)
 
template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same< typename SequenceContainer::value_type, Sim3< Scalar > >::value, optional< typename SequenceContainer::value_type > > average (SequenceContainer const &foo_Ts_bar, int max_num_iterations=20)
 
template<class... Args>
SOPHUS_FUNC void defaultEnsure (char const *function, char const *file, int line, char const *description, Args &&... args)
 
template<class T >
Vector2< T > normalFromSO2 (SO2< T > const &R_foo_line)
 
template<class T >
SO2< T > SO2FromNormal (Vector2< T > normal_foo)
 
template<class T >
Vector3< T > normalFromSO3 (SO3< T > const &R_foo_plane)
 
template<class T >
Matrix3< T > rotationFromNormal (Vector3< T > const &normal_foo, Vector3< T > xDirHint_foo=Vector3< T >(T(1), T(0), T(0)), Vector3< T > yDirHint_foo=Vector3< T >(T(0), T(1), T(0)))
 
template<class T >
SO3< T > SO3FromNormal (Vector3< T > const &normal_foo)
 
template<class T >
Line2< T > lineFromSE2 (SE2< T > const &T_foo_line)
 
template<class T >
SE2< T > SE2FromLine (Line2< T > const &line_foo)
 
template<class T >
Plane3< T > planeFromSE3 (SE3< T > const &T_foo_plane)
 
template<class T >
SE3< T > SE3FromPlane (Plane3< T > const &plane_foo)
 
template<class T , int N>
Eigen::Hyperplane< T, N > makeHyperplaneUnique (const Eigen::Hyperplane< T, N > &plane)
 
template<class G , class Scalar2 >
enable_if_t< interp_details::Traits< G >::supported, G > interpolate (G const &foo_T_bar, G const &foo_T_baz, Scalar2 p=Scalar2(0.5f))
 
void processTestResult (bool passed)
 
template<class T >
auto metric (T const &p0, T const &p1) -> decltype(details::Metric< T >::impl(p0, p1))
 
template<class T >
auto setToZero (T &p) -> decltype(details::SetToZero< T >::impl(p))
 
template<class T >
auto squaredNorm (T const &p) -> decltype(details::SquaredNorm< T >::impl(p))
 
template<typename T >
auto transpose (T const &p) -> decltype(details::Transpose< T >::impl(T()))
 

Variables

constexpr nullopt_t nullopt {}
 

Typedef Documentation

◆ enable_if_t

template<bool B, class T = void>
using Sophus::enable_if_t = typedef typename std::enable_if<B, T>::type

Definition at line 201 of file common.hpp.

◆ Line2

template<class T >
using Sophus::Line2 = typedef Eigen::Hyperplane<T, 2>

Definition at line 162 of file types.hpp.

◆ Line2d

using Sophus::Line2d = typedef Line2<double>

Definition at line 163 of file types.hpp.

◆ Line2f

using Sophus::Line2f = typedef Line2<float>

Definition at line 164 of file types.hpp.

◆ Matrix

template<class Scalar , int M, int N>
using Sophus::Matrix = typedef Eigen::Matrix<Scalar, M, N>

Definition at line 38 of file types.hpp.

◆ Matrix2

template<class Scalar >
using Sophus::Matrix2 = typedef Matrix<Scalar, 2, 2>

Definition at line 41 of file types.hpp.

◆ Matrix2d

using Sophus::Matrix2d = typedef Matrix2<double>

Definition at line 43 of file types.hpp.

◆ Matrix2f

using Sophus::Matrix2f = typedef Matrix2<float>

Definition at line 42 of file types.hpp.

◆ Matrix3

template<class Scalar >
using Sophus::Matrix3 = typedef Matrix<Scalar, 3, 3>

Definition at line 46 of file types.hpp.

◆ Matrix3d

using Sophus::Matrix3d = typedef Matrix3<double>

Definition at line 48 of file types.hpp.

◆ Matrix3f

using Sophus::Matrix3f = typedef Matrix3<float>

Definition at line 47 of file types.hpp.

◆ Matrix4

template<class Scalar >
using Sophus::Matrix4 = typedef Matrix<Scalar, 4, 4>

Definition at line 51 of file types.hpp.

◆ Matrix4d

using Sophus::Matrix4d = typedef Matrix4<double>

Definition at line 53 of file types.hpp.

◆ Matrix4f

using Sophus::Matrix4f = typedef Matrix4<float>

Definition at line 52 of file types.hpp.

◆ Matrix6

template<class Scalar >
using Sophus::Matrix6 = typedef Matrix<Scalar, 6, 6>

Definition at line 56 of file types.hpp.

◆ Matrix6d

using Sophus::Matrix6d = typedef Matrix6<double>

Definition at line 58 of file types.hpp.

◆ Matrix6f

using Sophus::Matrix6f = typedef Matrix6<float>

Definition at line 57 of file types.hpp.

◆ Matrix7

template<class Scalar >
using Sophus::Matrix7 = typedef Matrix<Scalar, 7, 7>

Definition at line 61 of file types.hpp.

◆ Matrix7d

using Sophus::Matrix7d = typedef Matrix7<double>

Definition at line 63 of file types.hpp.

◆ Matrix7f

using Sophus::Matrix7f = typedef Matrix7<float>

Definition at line 62 of file types.hpp.

◆ Plane3

template<class T >
using Sophus::Plane3 = typedef Eigen::Hyperplane<T, 3>

Definition at line 156 of file types.hpp.

◆ Plane3d

using Sophus::Plane3d = typedef Plane3<double>

Definition at line 157 of file types.hpp.

◆ Plane3f

using Sophus::Plane3f = typedef Plane3<float>

Definition at line 158 of file types.hpp.

◆ RxSO3d

using Sophus::RxSO3d = typedef RxSO3<double>

Definition at line 9 of file rxso3.hpp.

◆ RxSO3f

using Sophus::RxSO3f = typedef RxSO3<float>

Definition at line 10 of file rxso3.hpp.

◆ SE2d

using Sophus::SE2d = typedef SE2<double>

Definition at line 9 of file se2.hpp.

◆ SE2f

using Sophus::SE2f = typedef SE2<float>

Definition at line 10 of file se2.hpp.

◆ SE3d

using Sophus::SE3d = typedef SE3<double>

Definition at line 9 of file se3.hpp.

◆ SE3f

using Sophus::SE3f = typedef SE3<float>

Definition at line 10 of file se3.hpp.

◆ Sim3d

using Sophus::Sim3d = typedef Sim3<double>

Definition at line 9 of file sim3.hpp.

◆ Sim3f

using Sophus::Sim3f = typedef Sim3<float>

Definition at line 10 of file sim3.hpp.

◆ SO2d

using Sophus::SO2d = typedef SO2<double>

Definition at line 15 of file so2.hpp.

◆ SO2f

using Sophus::SO2f = typedef SO2<float>

Definition at line 16 of file so2.hpp.

◆ SO3d

using Sophus::SO3d = typedef SO3<double>

Definition at line 15 of file so3.hpp.

◆ SO3f

using Sophus::SO3f = typedef SO3<float>

Definition at line 16 of file so3.hpp.

◆ Vector

template<class Scalar , int M, int Options = 0>
using Sophus::Vector = typedef Eigen::Matrix<Scalar, M, 1, Options>

Definition at line 10 of file types.hpp.

◆ Vector2

template<class Scalar , int Options = 0>
using Sophus::Vector2 = typedef Vector<Scalar, 2, Options>

Definition at line 13 of file types.hpp.

◆ Vector2d

using Sophus::Vector2d = typedef Vector2<double>

Definition at line 15 of file types.hpp.

◆ Vector2f

using Sophus::Vector2f = typedef Vector2<float>

Definition at line 14 of file types.hpp.

◆ Vector3

template<class Scalar , int Options = 0>
using Sophus::Vector3 = typedef Vector<Scalar, 3, Options>

Definition at line 18 of file types.hpp.

◆ Vector3d

using Sophus::Vector3d = typedef Vector3<double>

Definition at line 20 of file types.hpp.

◆ Vector3f

using Sophus::Vector3f = typedef Vector3<float>

Definition at line 19 of file types.hpp.

◆ Vector4

template<class Scalar >
using Sophus::Vector4 = typedef Vector<Scalar, 4>

Definition at line 23 of file types.hpp.

◆ Vector4d

using Sophus::Vector4d = typedef Vector4<double>

Definition at line 25 of file types.hpp.

◆ Vector4f

using Sophus::Vector4f = typedef Vector4<float>

Definition at line 24 of file types.hpp.

◆ Vector6

template<class Scalar >
using Sophus::Vector6 = typedef Vector<Scalar, 6>

Definition at line 28 of file types.hpp.

◆ Vector6d

using Sophus::Vector6d = typedef Vector6<double>

Definition at line 30 of file types.hpp.

◆ Vector6f

using Sophus::Vector6f = typedef Vector6<float>

Definition at line 29 of file types.hpp.

◆ Vector7

template<class Scalar >
using Sophus::Vector7 = typedef Vector<Scalar, 7>

Definition at line 33 of file types.hpp.

◆ Vector7d

using Sophus::Vector7d = typedef Vector7<double>

Definition at line 35 of file types.hpp.

◆ Vector7f

using Sophus::Vector7f = typedef Vector7<float>

Definition at line 34 of file types.hpp.

Function Documentation

◆ average() [1/6]

template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same<typename SequenceContainer::value_type, SO2<Scalar> >::value, optional<typename SequenceContainer::value_type> > Sophus::average ( SequenceContainer const &  foo_Ts_bar)

◆ average() [2/6]

template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same<typename SequenceContainer::value_type, SO3<Scalar> >::value, optional<typename SequenceContainer::value_type> > Sophus::average ( SequenceContainer const &  foo_Ts_bar)

◆ average() [3/6]

template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same<typename SequenceContainer::value_type, RxSO3<Scalar> >::value, optional<typename SequenceContainer::value_type> > Sophus::average ( SequenceContainer const &  foo_Ts_bar)

◆ average() [4/6]

template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same<typename SequenceContainer::value_type, SE2<Scalar> >::value, optional<typename SequenceContainer::value_type> > Sophus::average ( SequenceContainer const &  foo_Ts_bar,
int  max_num_iterations = 20 
)

Definition at line 157 of file average.hpp.

References iterativeMean(), and exprtk::details::value().

◆ average() [5/6]

template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same<typename SequenceContainer::value_type, SE3<Scalar> >::value, optional<typename SequenceContainer::value_type> > Sophus::average ( SequenceContainer const &  foo_Ts_bar,
int  max_num_iterations = 20 
)

Definition at line 168 of file average.hpp.

References iterativeMean(), and exprtk::details::value().

◆ average() [6/6]

template<class SequenceContainer , class Scalar = typename SequenceContainer::value_type::Scalar>
enable_if_t< std::is_same<typename SequenceContainer::value_type, Sim3<Scalar> >::value, optional<typename SequenceContainer::value_type> > Sophus::average ( SequenceContainer const &  foo_Ts_bar,
int  max_num_iterations = 20 
)

Definition at line 177 of file average.hpp.

References iterativeMean().

◆ defaultEnsure()

template<class... Args>
SOPHUS_FUNC void Sophus::defaultEnsure ( char const *  function,
char const *  file,
int  line,
char const *  description,
Args &&...  args 
)

Definition at line 116 of file common.hpp.

◆ interpolate()

template<class G , class Scalar2 >
enable_if_t<interp_details::Traits<G>::supported, G> Sophus::interpolate ( G const &  foo_T_bar,
G const &  foo_T_baz,
Scalar2  p = Scalar2(0.5f) 
)

Definition at line 24 of file interpolate.hpp.

References SOPHUS_ENSURE.

◆ iterativeMean()

template<class SequenceContainer >
optional<typename SequenceContainer::value_type> Sophus::iterativeMean ( SequenceContainer const &  foo_Ts_bar,
int  max_num_iterations 
)

Definition at line 15 of file average.hpp.

References average(), nullopt, SOPHUS_ENSURE, and exprtk::details::value().

Referenced by average().

◆ lineFromSE2()

template<class T >
Line2<T> Sophus::lineFromSE2 ( SE2< T > const &  T_foo_line)

◆ makeHyperplaneUnique()

template<class T , int N>
Eigen::Hyperplane<T, N> Sophus::makeHyperplaneUnique ( const Eigen::Hyperplane< T, N > &  plane)

Definition at line 165 of file geometry.hpp.

◆ metric()

template<class T >
auto Sophus::metric ( T const &  p0,
T const &  p1 
) -> decltype(details::Metric<T>::impl(p0, p1))

Definition at line 127 of file types.hpp.

References Sophus::details::Metric< Scalar >::impl().

◆ normalFromSO2()

template<class T >
Vector2<T> Sophus::normalFromSO2 ( SO2< T > const &  R_foo_line)

Definition at line 16 of file geometry.hpp.

References Sophus::SO2Base< SO2< Scalar_, Options > >::matrix().

Referenced by lineFromSE2().

◆ normalFromSO3()

template<class T >
Vector3<T> Sophus::normalFromSO3 ( SO3< T > const &  R_foo_plane)

Definition at line 38 of file geometry.hpp.

References Sophus::SO3Base< SO3< Scalar_, Options > >::matrix().

Referenced by planeFromSE3().

◆ planeFromSE3()

template<class T >
Plane3<T> Sophus::planeFromSE3 ( SE3< T > const &  T_foo_plane)

◆ processTestResult()

void Sophus::processTestResult ( bool  passed)

Definition at line 38 of file test_macros.hpp.

◆ rotationFromNormal()

template<class T >
Matrix3<T> Sophus::rotationFromNormal ( Vector3< T > const &  normal_foo,
Vector3< T >  xDirHint_foo = Vector3<T>(T(1), T(0),                                                                   T(0)),
Vector3< T >  yDirHint_foo = Vector3<T>(T(0), T(1),                                                                   T(0)) 
)

Definition at line 55 of file geometry.hpp.

References det(), Sophus::Constants< Scalar >::epsilon(), and SOPHUS_ENSURE.

Referenced by SO3FromNormal().

◆ SE2FromLine()

template<class T >
SE2<T> Sophus::SE2FromLine ( Line2< T > const &  line_foo)

Definition at line 132 of file geometry.hpp.

References SO2FromNormal().

◆ SE3FromPlane()

template<class T >
SE3<T> Sophus::SE3FromPlane ( Plane3< T > const &  plane_foo)

Definition at line 154 of file geometry.hpp.

References SO3FromNormal().

◆ setToZero()

template<class T >
auto Sophus::setToZero ( T &  p) -> decltype(details::SetToZero<T>::impl(p))

Definition at line 135 of file types.hpp.

References Sophus::details::SetToZero< Scalar >::impl().

◆ SO2FromNormal()

template<class T >
SO2<T> Sophus::SO2FromNormal ( Vector2< T >  normal_foo)

Definition at line 26 of file geometry.hpp.

References Sophus::Constants< Scalar >::epsilon(), and SOPHUS_ENSURE.

Referenced by SE2FromLine().

◆ SO3FromNormal()

template<class T >
SO3<T> Sophus::SO3FromNormal ( Vector3< T > const &  normal_foo)

Definition at line 113 of file geometry.hpp.

References rotationFromNormal().

Referenced by SE3FromPlane().

◆ squaredNorm()

template<class T >
auto Sophus::squaredNorm ( T const &  p) -> decltype(details::SquaredNorm<T>::impl(p))

◆ transpose()

template<typename T >
auto Sophus::transpose ( T const &  p) -> decltype(details::Transpose<T>::impl(T()))

Variable Documentation

◆ nullopt

constexpr nullopt_t Sophus::nullopt {}

Definition at line 162 of file common.hpp.

Referenced by iterativeMean().




Page generated by Doxygen 1.8.13 for MRPT 1.5.3 at Tue Oct 31 07:27:35 UTC 2017