Normal.hpp

Go to the documentation of this file.

 
/*
 * Normal.hpp
 *
 *  @date 03.06.2017
 *  @author Lukas Kalbertodt <lukas.kalbertodt@gmail.com>
 */
 
#ifndef LVR2_GEOMETRY_NORMAL_H_
#define LVR2_GEOMETRY_NORMAL_H_
 
#include <ostream>
 
// Eigen sometimes produces errors when compiled with CUDA. Disables
// all Eigen related function for CUDA code (which is currently fine).
#ifndef __NVCC__
#include <Eigen/Dense>
#endif
 
#include "lvr2/geometry/BaseVector.hpp"
 
namespace lvr2
{
 
 
template <typename CoordType>
struct Normal : public BaseVector<CoordType>
{
    Normal() { this->x = 0; this->y = 1; this->z = 0;}
 
 
    // ^ Private inheritance to restrict modifying access to the vector's data
    // in order to prevent modifications that would result in a non-normalized
    // vector.
 
    explicit Normal(BaseVector<CoordType> base);
 
    Normal(
        CoordType x,
        CoordType y,
        CoordType z
    );
 
 
    // Since the fields x, y and z can't be access directly anymore (else the
    // user could invalidate this *normal*), we provide getter methods.
    CoordType getX() const
    {
        return this->x;
    }
    
    CoordType getY() const
    {
        return this->y;
    }
    
    CoordType getZ() const
    {
        return this->z;
    }
 
    template<typename CollectionT>
    static Normal<CoordType>& average(const CollectionT& normals);
 
    template<typename T>
    Normal<CoordType>& operator=(const T& other);
 
    template<typename T>
    Normal<CoordType> operator+(const T& other) const;
 
    template<typename T>
    Normal<CoordType> operator-(const T& other) const;
    
    Normal<CoordType> operator-() const;
 
// Eigen sometimes produces errors when compiled with CUDA. Disables
// all Eigen related function for CUDA code (which is currently fine).
#ifndef __NVCC__
    // Friend declaration for Eigen multiplication
    template<typename T, typename S>
    friend Normal<T> operator*(const Eigen::Matrix<S, 4, 4>& mat, const Normal<T>& normal);
#endif // ifndef __NVCC__
 
};
 
template<typename CoordType>
inline std::ostream& operator<<(std::ostream& os, const Normal<CoordType>& n)
{
    os << "Normal[" << n.getX() << ", " << n.getY() << ", " << n.getZ() << "]";
    return os;
}
 
// Eigen sometimes produces errors when compiled with CUDA. Disables
// all Eigen related function for CUDA code (which is currently fine).
#ifndef __NVCC__
 
template<typename CoordType, typename Scalar = CoordType>
inline Normal<CoordType> operator*(const Eigen::Matrix<Scalar, 4, 4>& mat, const Normal<CoordType>& normal)
{
    // TODO: CHECK IF THIS IS CORRECT
    CoordType x = mat(0, 0) * normal.x + mat(1, 0) * normal.y + mat(2, 0) * normal.z;
    CoordType y = mat(0, 1) * normal.x + mat(1, 1) * normal.y + mat(2, 1) * normal.z;
    CoordType z = mat(0, 2) * normal.x + mat(1, 2) * normal.y + mat(2, 2) * normal.z;
    return Normal<CoordType>(x,y,z);
}
#endif // ifndef __NVCC__
 
} // namespace lvr2
 
#include "lvr2/geometry/Normal.tcc"
 
#endif /* LVR2_GEOMETRY_NORMAL_H_ */