MatrixTypes.hpp

Go to the documentation of this file.

 
#ifndef LVR2_TYPES_MATRIXTYPES_HPP
#define LVR2_TYPES_MATRIXTYPES_HPP
 
#include <Eigen/Dense>
 
namespace lvr2
{
template<typename T> 
using Matrix4RM = Eigen::Matrix<T, 4, 4, Eigen::RowMajor>;
 
using Matrix4fRM = Matrix4RM<float>;
 
using Matrix4dRM = Matrix4RM<double>;
 
template<typename T> 
using Matrix3RM = Eigen::Matrix<T, 3, 3, Eigen::RowMajor>;
 
using Matrix3fRM = Matrix3RM<float>;
using Matrix3dRM = Matrix3RM<double>;
 
template<typename T>
using Transform = Eigen::Matrix<T, 4, 4>;
 
using Transformf = Transform<float>;
 
using Transformd = Transform<double>;
 
template<typename T>
using Rotation = Eigen::Matrix<T, 3, 3>;
 
using Rotationf = Rotation<float>;
 
using Rotationd = Rotation<double>;
 
template<typename T>
using Extrinsics = Eigen::Matrix<T, 4, 4>;
 
using Extrinsicsf = Extrinsics<float>;
 
using Extrinsicsd = Extrinsics<double>;
 
template<typename T>
using Intrinsics = Eigen::Matrix<T, 3, 3>;
 
using Intrinsicsf = Intrinsics<float>;
 
using Intrinsicsd = Intrinsics<double>;
 
template<typename T>
using Distortion = Eigen::Matrix<T, 6, 1>;
 
using Distortiond = Distortion<double>;
 
using Distortionf = Distortion<float>;
 
template<typename T>
using Vector3 = Eigen::Matrix<T, 3, 1>;
 
using Vector3f = Eigen::Vector3f;
 
using Vector3d = Eigen::Vector3d;
 
using Vector3i = Eigen::Vector3i;
 
template<typename T>
using Vector4 = Eigen::Matrix<T, 4, 1>;
 
using Vector4f = Eigen::Vector4f;
 
using Vector4d = Eigen::Vector4d;
 
template<typename T>
using Vector2 = Eigen::Matrix<T, 2, 1>;
 
using Vector2f = Eigen::Vector2f;
 
using Vector2d = Eigen::Vector2d;
 
using Matrix4f = Eigen::Matrix4f;
 
using Matrix4d = Eigen::Matrix4d;
 
using Matrix6f = Eigen::Matrix<float, 6, 6>;
 
using Vector6f = Eigen::Matrix<float, 6, 1>;
 
using Matrix6d = Eigen::Matrix<double, 6, 6>;
 
using Vector6d = Eigen::Matrix<double, 6, 1>;
 
template<typename T> 
Vector3<T> multiply(const Transform<T>& transform, const Vector3<T>& p)
{
    Vector4<T> ret(p.coeff(0), p.coeff(1), p.coeff(2), 1.0);
    ret = transform * ret;
    return Vector3<T>(ret.coeff(0), ret.coeff(1), ret.coeff(2));
}
 
} // namespace lvr2
 
// additional operators
 
 
 
 
template<typename T>
lvr2::Vector3<T> operator*(const lvr2::Transform<T>& transform, const lvr2::Vector3<T>& p)
{
    return lvr2::multiply(transform, p);
}
 
#endif // LVR2_TYPES_MATRIXTYPES_HPP