ColorVertex.hpp

Go to the documentation of this file.

/*
 * ColorVertex.hpp
 *
 *  @date 17.06.2011
 *  @author Thomas Wiemann
 */

#ifndef COLORVERTEX_H_
#define COLORVERTEX_H_

#include "lvr2/geometry/BaseVector.hpp"

#include <ostream>

namespace lvr2
{


template<typename T, typename ColorT>
class ColorVertex : public BaseVector<T>
{
public:

    using CoordType = T;
        ColorVertex()
        {
                this->x = this->y = this->z = 0;
                this->r = this->g = this->b = 0;
                fusion = false;
        }

        ColorVertex(const CoordType &_x, const CoordType &_y, const CoordType &_z)
        {
                this->x = _x;
                this->y = _y;
                this->z = _z;
                this->r = 0;
                this->g = 100;
                this->b = 0;
                fusion = false;
        }

        ColorVertex(const CoordType &_x, const CoordType &_y, const CoordType &_z,
                        const unsigned char _r, const unsigned char _g, const unsigned char _b, ...)
        {
                this->x = _x;
                this->y = _y;
                this->z = _z;
                this->r = _r;
                this->g = _g;
                this->b = _b;
                fusion = false;
        }

        ColorVertex(const ColorVertex &o)
        {
                this->x = o.x;
                this->y = o.y;
                this->z = o.z;
                this->r = o.r;
                this->g = o.g;
                this->b = o.b;
                this->fusion = o.fusion;
        }

        ColorVertex(const T &o)
        {
                this->x = o.x;
                this->y = o.y;
                this->z = o.z;
                this->r = 0;
                this->g = 0;
                this->b = 0;
        }


    CoordType operator[](const int &index) const
    {

        switch ( index )
        {
            case 0: return this->x;
            case 1: return this->y;
            case 2: return this->z;
            case 3: return *((CoordType*) &r);
            case 4: return *((CoordType*) &g);
            case 5: return *((CoordType*) &b);
            case 6: return *((CoordType*) &fusion);
            default:
                throw std::overflow_error( "Access index out of range." );
        }
    }


    CoordType& operator[](const int &index)
    {
        switch ( index )
        {
            case 0: return this->x;
            case 1: return this->y;
            case 2: return this->z;
            case 3: return *((CoordType*) &r);
            case 4: return *((CoordType*) &g);
            case 5: return *((CoordType*) &b);
            case 6: return *((CoordType*) &fusion);
            default:
                throw std::overflow_error("Access index out of range.");
        }
    }


        ColorT r, g, b;
        bool fusion;

};

using uColorVertex = ColorVertex<float, unsigned char>;


template<typename CoordType, typename ColorT>
inline std::ostream& operator<<(std::ostream& os, const ColorVertex<CoordType, ColorT> v){
        os << "ColorVertex: " << v.x << " " << v.y << " " << v.z << " " << (int)v.r << " " << (int)v.g << " " << (int)v.b << std::endl;
        return os;
}

} // namespace lvr22

#endif /* COLORVERTEX_H_ */