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_ */