math_frwds.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
#ifndef mrpt_math_forwddecls_H
#define mrpt_math_forwddecls_H
 
#include <mrpt/config.h>
#include <mrpt/poses/poses_frwds.h>
#include <string>
 
/*! \file math_frwds.h
  * Forward declarations of all mrpt::math classes related to vectors, arrays
 * and matrices.
  * Many of the function implementations are in ops_matrices.h, others in
 * ops_containers.h
  */
 
namespace mrpt
{
namespace utils
{
class CStream;
}
 
namespace system
{
std::string MRPT_getVersion();
}
 
namespace math
{
struct TPoint2D;
struct TPoint3D;
struct TPose2D;
struct TPose3D;
struct TPose3DQuat;
 
class CMatrix;  // mrpt-binary-serializable matrix
class CMatrixD;  // mrpt-binary-serializable matrix
 
namespace detail
{
/** Internal resize which compiles to nothing on fixed-size matrices. */
template <typename MAT, int TypeSizeAtCompileTime>
struct TAuxResizer
{
        static inline void internal_resize(MAT&, size_t, size_t) {}
        static inline void internal_resize(MAT&, size_t) {}
};
template <typename MAT>
struct TAuxResizer<MAT, -1>
{
        static inline void internal_resize(MAT& obj, size_t row, size_t col)
        {
                obj.derived().conservativeResize(row, col);
        }
        static inline void internal_resize(MAT& obj, size_t nsize)
        {
                obj.derived().conservativeResize(nsize);
        }
};
}
 
/*! Selection of the number format in CMatrixTemplate::saveToTextFile
  */
enum TMatrixTextFileFormat
{
        /** engineering format '%e' */
        MATRIX_FORMAT_ENG = 0,
        /** fixed floating point '%f' */
        MATRIX_FORMAT_FIXED = 1,
        /** intergers '%i' */
        MATRIX_FORMAT_INT = 2
};
 
/** For usage in one of the constructors of CMatrixFixedNumeric or
   CMatrixTemplate (and derived classes), if it's not required
         to fill it with zeros at the constructor to save time. */
enum TConstructorFlags_Matrices
{
        UNINITIALIZED_MATRIX = 0
};
 
// ---------------- Forward declarations: Classes ----------------
template <class T>
class CMatrixTemplate;
template <class T>
class CMatrixTemplateObjects;
template <class T>
class CQuaternion;
 
/** ContainerType<T>::element_t exposes the value of any STL or Eigen container.
  *  Default specialization works for STL and MRPT containers, there is another
 * one for Eigen in <mrpt/math/eigen_frwds.h> */
template <typename CONTAINER>
struct ContainerType
{
        typedef typename CONTAINER::value_type element_t;
};
 
#define MRPT_MATRIX_CONSTRUCTORS_FROM_POSES(_CLASS_)           \
        explicit inline _CLASS_(const mrpt::math::TPose2D& p)      \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }                                                          \
        explicit inline _CLASS_(const mrpt::math::TPose3D& p)      \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }                                                          \
        explicit inline _CLASS_(const mrpt::math::TPose3DQuat& p)  \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }                                                          \
        explicit inline _CLASS_(const mrpt::math::TPoint2D& p)     \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }                                                          \
        explicit inline _CLASS_(const mrpt::math::TPoint3D& p)     \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }                                                          \
        explicit inline _CLASS_(const mrpt::poses::CPose2D& p)     \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }                                                          \
        explicit inline _CLASS_(const mrpt::poses::CPose3D& p)     \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }                                                          \
        explicit inline _CLASS_(const mrpt::poses::CPose3DQuat& p) \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }                                                          \
        explicit inline _CLASS_(const mrpt::poses::CPoint2D& p)    \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }                                                          \
        explicit inline _CLASS_(const mrpt::poses::CPoint3D& p)    \
        {                                                          \
                mrpt::math::containerFromPoseOrPoint(*this, p);        \
        }
 
template <class CONTAINER1, class CONTAINER2>
void cumsum(const CONTAINER1& in_data, CONTAINER2& out_cumsum);
 
template <class CONTAINER>
inline typename CONTAINER::Scalar norm(const CONTAINER& v);
template <class CONTAINER>
inline typename CONTAINER::Scalar norm_inf(const CONTAINER& v);
 
template <class MAT_A, class SKEW_3VECTOR, class MAT_OUT>
void multiply_A_skew3(const MAT_A& A, const SKEW_3VECTOR& v, MAT_OUT& out);
template <class SKEW_3VECTOR, class MAT_A, class MAT_OUT>
void multiply_skew3_A(const SKEW_3VECTOR& v, const MAT_A& A, MAT_OUT& out);
 
namespace detail
{
// Implemented in "lightweight_geom_data.cpp"
/** Convert a pose into a light-weight structure (functional form, needed for
 * forward declarations) */
TPoint2D lightFromPose(const mrpt::poses::CPoint2D& p);
/** Convert a pose into a light-weight structure (functional form, needed for
 * forward declarations) */
TPoint3D lightFromPose(const mrpt::poses::CPoint3D& p);
/** Convert a pose into a light-weight structure (functional form, needed for
 * forward declarations) */
TPose2D lightFromPose(const mrpt::poses::CPose2D& p);
/** Convert a pose into a light-weight structure (functional form, needed for
 * forward declarations) */
TPose3D lightFromPose(const mrpt::poses::CPose3D& p);
/** Convert a pose into a light-weight structure (functional form, needed for
 * forward declarations) */
TPose3DQuat lightFromPose(const mrpt::poses::CPose3DQuat& p);
 
template <class MATORG, class MATDEST>
void extractMatrix(
        const MATORG& M, const size_t first_row, const size_t first_col,
        MATDEST& outMat);
}
 
/** Conversion of poses (TPose2D,TPoint2D,...,
 * mrpt::poses::CPoint2D,CPose3D,...) to MRPT containers (vector/matrix) */
template <class CONTAINER, class POINT_OR_POSE>
CONTAINER& containerFromPoseOrPoint(CONTAINER& C, const POINT_OR_POSE& p);
 
// Vicinity classes ----------------------------------------------------
namespace detail
{
/**
  * The purpose of this class is to model traits for containers, so that they
 * can be used as return values for the function CMatrixTemplate::getVicinity.
  * This class is NOT defined for any base container, because correctness would
 * not be guaranteed. Instead, each class must define its own specialization
  * of the template, containing two functions:
  * - static void initialize(container<T>,size_t N): must reserve space to allow
 * at least the insertion of N*N elements, in a square fashion when appliable.
  * - static void insertInContainer(container<T>,size_t r,size_t c,const T &):
 * must insert the given element in the container. Whenever it's possible, it
  * must insert it in the (r,c) coordinates.
  * For linear containers, the vicinity functions are guaranteed to insert
 * elements in order, i.e., starting from the top and reading from left to
 * right.
  */
template <typename T>
class VicinityTraits;
 
/**
  * This huge template encapsulates a function to get the vicinity of an
 * element, with maximum genericity. Although it's not meant to be called
 * directly,
  * every type defining the ASSERT_ENOUGHROOM assert and the get_unsafe method
 * will work. The assert checks if the boundaries (r-N,r+N,c-N,c+N) fit in
  * the matrix.
  * The template parameters are the following:
  * - MatrixType: the matrix or container base type, from which the vicinity is
 * required.
  * - T: the base type of the matrix or container.
  * - ReturnType: the returning container type. The class
 * VicinityTraits<ReturnType> must be completely defined.
  * - D: the dimension of the vicinity. Current implementations are 4, 5, 8, 9,
 * 12, 13, 20, 21, 24 and 25, although it's easy to implement new variants.
  */
template <typename MatrixType, typename T, typename ReturnType, size_t D>
struct getVicinity;
}
 
// Other forward decls:
template <class T>
T wrapTo2Pi(T a);
 
}  // End of namespace
}  // End of namespace
 
#endif