BaseBuffer.hpp

Go to the documentation of this file.

#pragma once

#ifndef LVR2_TYPES_BASEBUFFER
#define LVR2_TYPES_BASEBUFFER

#include <algorithm>
#include <vector>
#include "MultiChannelMap.hpp"
#include "lvr2/io/DataStruct.hpp"

namespace lvr2 {

using intOptional = boost::optional<int>;
using floatOptional = boost::optional<float>;
using ucharOptional = boost::optional<unsigned char>;

using FloatProxy = ElementProxy<float>;
using UCharProxy = ElementProxy<unsigned char>;
using IndexProxy = ElementProxy<unsigned int>;

class BaseBuffer : public MultiChannelMap {
using base = MultiChannelMap;
public:
    using base::base;


    template<typename T>
    size_t channelWidth(const std::string& name) const;

    inline size_t ucharChannelWidth(const std::string& name) const
    {
        return channelWidth<unsigned char>(name);
    }

    inline size_t floatChannelWidth(const std::string& name) const
    {
        return channelWidth<float>(name);
    }

    inline size_t indexChannelWidth(const std::string& name) const
    {
        return channelWidth<unsigned int>(name);
    }


    template<typename T>
    bool hasChannel(const std::string& name) const;

    inline bool hasUCharChannel(const std::string& name) const
    {
        return hasChannel<unsigned char>(name);
    }

    inline bool hasFloatChannel(const std::string& name) const
    {
        return hasChannel<float>(name);
    }

    inline bool hasIndexChannel(const std::string& name) const
    {
        return hasChannel<unsigned int>(name);
    }


    template<typename T>
    void addChannel(typename Channel<T>::Ptr data, const std::string& name);

    inline void addFloatChannel(FloatChannelPtr data, const std::string& name)
    {
        addChannel<float>(data, name);
    }

    inline void addUCharChannel(UCharChannelPtr data, const std::string& name)
    {
        addChannel<unsigned char>(data, name);
    }

    inline void addIndexChannel(IndexChannelPtr data, const std::string& name)
    {
        addChannel<unsigned int>(data, name);
    }

    template<typename T>
    void addChannel(boost::shared_array<T> array, std::string name, size_t n, size_t width);

    inline void addIndexChannel( indexArray array, std::string name, size_t n, size_t width)
    {
        addChannel<unsigned int>(array, name, n, width);
    }

    inline void addFloatChannel( floatArr array, std::string name, size_t n, size_t width)
    {
        addChannel<float>(array, name, n, width);
    }

    inline void addUCharChannel(ucharArr array, std::string name, size_t n, size_t width)
    {
        addChannel<unsigned char>(array, name, n, width);
    }

    template<typename T>
    void addEmptyChannel( const std::string& name, size_t n, size_t width);

    inline void addEmptyFloatChannel( const std::string& name, size_t n, size_t width)
    {
        addEmptyChannel<float>(name, n, width);
    }

    inline void addEmptyUCharChannel( const std::string& name, size_t n, size_t width)
    {
        addEmptyChannel<unsigned char>(name, n, width);
    }

    inline void addEmptyIndexChannel( const std::string& name, size_t n, size_t width)
    {
        addEmptyChannel<unsigned int>(name, n, width);
    }

    
    template<typename T>
    bool removeChannel(const std::string& name);

    bool removeIndexChannel(const std::string& name)
    {
        return removeChannel<unsigned int>(name);
    }

    bool removeFloatChannel(const std::string& name)
    {
        return removeChannel<float>(name);
    }

    bool removeUCharChannel(const std::string& name)
    {
        return removeChannel<unsigned char>(name);
    }

    //
   
    template <typename T>
    int getAllChannelsOfType(std::map<std::string, Channel<T> >& channels)
    {
        for(auto it = this->typedBegin<T>(); it != this->end(); ++it)
        {
            channels.insert(*it);
        }
        return index_of_type<T>::value;
    }

    template <typename T>
    int getAllChannelsOfType(std::vector<std::pair<std::string, Channel<T> >>& channels)
    {
        for(auto it = this->typedBegin<T>(); it != this->end(); ++it)
        {
            channels.push_back({it->first, it->second});
        }
        return index_of_type<T>::value;
    }


    template<typename T>
    typename Channel<T>::Optional getChannel(const std::string& name);

    template<typename T>
    const typename Channel<T>::Optional getChannel(const std::string& name) const;


    inline Channel<float>::Optional getFloatChannel(const std::string& name)
    {
        return getChannel<float>(name);
    }

    inline Channel<unsigned char>::Optional getUCharChannel(const std::string& name)
    {
        return getChannel<unsigned char>(name);
    }

    inline Channel<unsigned int>::Optional getIndexChannel(const std::string& name)
    {
        return getChannel<unsigned int>(name);
    }

    inline void getChannel(const std::string& name, FloatChannelOptional& channelOptional )
    { 
        channelOptional = getFloatChannel(name);
    }

    inline void getChannel(const std::string& name, IndexChannelOptional& channelOptional)
    {
        channelOptional = getIndexChannel(name);
    }

    inline void getChannel(const std::string& name, UCharChannelOptional& channelOptional)
    {
        channelOptional = getUCharChannel(name);
    }


    template<typename T>
    ElementProxy<T> getHandle(unsigned int idx, const std::string& name);
    
    inline FloatProxy getFloatHandle(unsigned int idx, const std::string& name)
    {
        return getHandle<float>(idx, name);
    }

    inline UCharProxy getUCharHandle(unsigned int idx, const std::string& name)
    {
        return getHandle<unsigned char>(idx, name);
    }
    
    inline IndexProxy getIndexHandle(unsigned int idx, const std::string& name)
    {
        return getHandle<unsigned int>(idx, name);
    }


    template<typename T>
    boost::shared_array<T> getArray(const std::string& name, size_t& n, size_t& w);

    inline floatArr getFloatArray(const std::string& name, size_t& n, size_t& w)
    {
        return getArray<float>(name, n, w);
    }

    inline ucharArr getUCharArray(const std::string& name, size_t& n, size_t& w)
    {
        return getArray<unsigned char>(name, n, w);
    }

    inline indexArray getIndexArray(const std::string& name, size_t& n, size_t& w)
    {
        return getArray<unsigned int>(name, n, w);
    }


    template<typename T>
    void addAtomic(T data, const std::string& name);

    inline void addFloatAtomic(float data, const std::string& name)
    {
        addAtomic(data, name);
    }

    inline void addUCharAtomic(unsigned char data, const std::string& name)
    {
        addAtomic(data, name);
    }

    inline void addIntAtomic(int data, const std::string& name)
    {
        addAtomic(data, name);
    }

    template<typename T>
    boost::optional<T> getAtomic(const std::string& name);

    inline floatOptional getFloatAtomic(const std::string& name)
    {
        return getAtomic<float>(name);
    }

    inline ucharOptional getUCharAtomic(const std::string& name)
    {
        return getAtomic<unsigned char>(name);
    }

    inline intOptional getIntAtomic(const std::string& name)
    {
        return getAtomic<int>(name);
    }

    template<typename V>
    BaseBuffer manipulate(V visitor)
    {
        BaseBuffer cm;
        for(auto vchannel: *this)
        {
            cm.insert({vchannel.first, boost::apply_visitor(visitor, vchannel.second)});
        }
        return cm;
    }

    BaseBuffer clone() const {
        BaseBuffer ret;

        for(auto elem : *this)
        {
            ret.insert({elem.first, elem.second.clone()});
        }

        return ret;
    }
};

} // namespace lvr2

#include "BaseBuffer.tcc"

#endif // LVR2_TYPES_BASEBUFFER