BaseVector.hpp

Go to the documentation of this file.

 
/*
 * BaseVector.hpp
 *
 *  @date 02.06.2017
 *  @author Lukas Kalbertodt <lukas.kalbertodt@gmail.com>
 */
 
#ifndef LVR2_GEOMETRY_BASEVECTOR_H_
#define LVR2_GEOMETRY_BASEVECTOR_H_
 
// 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 <iostream>
 
namespace lvr2
{
 
template <typename> struct Normal;
 
template <typename CoordT>
struct BaseVector
{
public:
    using CoordType = CoordT;
 
    CoordT x;
    CoordT y;
    CoordT z;
 
    BaseVector() : x(0), y(0), z(0) {}
 
    BaseVector(const CoordT &x, const CoordT &y, const CoordT &z)
        : x(x), y(y), z(z)
    {
    }
 
    BaseVector(const BaseVector& o) : x(o.x), y(o.y), z(o.z)
    {
    }
    // ========================================================================
    // === Named operations
    // ========================================================================
 
    CoordT length() const;
 
    CoordT length2() const;
 
    CoordT distance(const BaseVector &other) const;
 
    CoordT distance2(const BaseVector &other) const;
 
    BaseVector<CoordT> cross(const BaseVector &other) const;
    
    BaseVector<CoordT> rotated(const BaseVector &n, const double &alpha) const;
 
    CoordT dot(const BaseVector &other) const;
 
   
    void normalize()
    {
        // Check for invalid vector. This check can be disabled in release mode,
        // which will probably lead to +inf and -inf values. In the documentation
        // for this function we require the vector to not be the null-vector.
        // assert(!(this->x == 0 && this->y == 0 && this->z == 0));
        if(!(this->x == 0 && this->y == 0 && this->z == 0))
        {
            auto len = this->length();
            this->x /= len;
            this->y /= len;
            this->z /= len;
        }
    }
 
 
    // ========================================================================
    // === Operator overloads
    // ========================================================================
 
    BaseVector<CoordT> operator*(const CoordT &scale) const;
    BaseVector<CoordT> operator/(const CoordT &scale) const;
 
    BaseVector<CoordT>& operator*=(const CoordT &scale);
    BaseVector<CoordT>& operator/=(const CoordT &scale);
 
    BaseVector<CoordT> operator+(const BaseVector &other) const;
    BaseVector<CoordT> operator-(const BaseVector &other) const;
 
    BaseVector<CoordT>& operator+=(const BaseVector<CoordT> &other);
    BaseVector<CoordT>& operator-=(const BaseVector<CoordT> &other);
 
    CoordType distanceFrom(const BaseVector<CoordT> &other) const;
    CoordType squaredDistanceFrom(const BaseVector<CoordType> &other) const;
 
    template<typename CollectionT>
    static BaseVector<CoordT> centroid(const CollectionT& points);
 
 
    template<typename CollectionT>
    static BaseVector<CoordT> average(const CollectionT& vecs);
 
    Normal<CoordT> normalized() const;
 
    bool operator==(const BaseVector &other) const;
    bool operator!=(const BaseVector &other) const;
 
    CoordT operator*(const BaseVector<CoordType> &other) const;
 
    CoordT operator[](const unsigned& index) const;
 
    CoordT& operator[](const unsigned& index);
 
// 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 BaseVector<T> operator*(const Eigen::Matrix<S, 4, 4>& mat, const BaseVector<T>& normal);
 
#endif // ifndef __NVCC__
 
};
 
template<typename T>
std::ostream& operator<<( std::ostream& os, const BaseVector<T>& v)
{
    os << "Vec: [" << v.x << " " << v.y << " " << v.z << "]" << std::endl;
    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 BaseVector<CoordType> operator*(const Eigen::Matrix<Scalar, 4, 4>& mat, const BaseVector<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;
 
    x += mat(0, 3);
    y += mat(1, 3);
    z += mat(2, 3);
 
    return BaseVector<CoordType>(x,y,z);
}
 
#endif // ifndef __NVCC__
 
} // namespace lvr
 
#include "lvr2/geometry/BaseVector.tcc"
 
#endif /* LVR2_GEOMETRY_BASEVECTOR_H_ */