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