BaseBufferManipulators.hpp

Go to the documentation of this file.

#pragma once

#include <random>
#include <chrono>
#include <algorithm>
#include <unordered_set>
#include <memory>
#include <boost/core/typeinfo.hpp>

#include "lvr2/types/MultiChannelMap.hpp"

namespace lvr2 {

namespace manipulators {

class Slice : public boost::static_visitor< MultiChannelMap::val_type > 
{
public:
    Slice(size_t left, size_t right)
    :m_left(left)
    ,m_right(right)
    {}

    template<typename T>
    MultiChannelMap::val_type operator()(Channel<T>& channel) const
    {
        MultiChannelMap::val_type vres;

        const size_t range = m_right - m_left;
        if(range < channel.numElements())
        {
            Channel<T> ret(range, channel.width());
            for(size_t i = m_left; i<m_right; i++)
            {
                for(int j=0; j<channel.width(); j++)
                {
                    ret[i-m_left][j] = channel[i][j];
                }
            }
            vres = ret;
        } else {
            vres = channel;
        }

        return vres;
    }
private:
    const size_t m_left;
    const size_t m_right;
};

template<typename T>
inline void no_delete(T* x)
{

}

class SliceShallow : public boost::static_visitor< MultiChannelMap::val_type > 
{
public:
    SliceShallow(size_t left, size_t right)
    :m_left(left)
    ,m_right(right)
    {}

    template<typename T>
    MultiChannelMap::val_type operator()(Channel<T>& channel) const
    {
        MultiChannelMap::val_type vres;

        const size_t range = m_right - m_left;

        size_t offset = m_left * channel.width();

        boost::core::typeinfo const & ti = BOOST_CORE_TYPEID(T);

        boost::shared_array<T> shallow_ptr(
            channel.dataPtr().get() + offset,
            no_delete<T>
        );

        Channel<T> ret(
            range,
            channel.width(),
            shallow_ptr
        );
        
        vres = ret;
        return vres;
    }
private:
    const size_t m_left;
    const size_t m_right;
};

class RandomSample : public boost::static_visitor< MultiChannelMap::val_type > 
{
public:
    RandomSample(size_t num_samples)
    :m_num_samples(num_samples)
    ,m_seed(std::chrono::steady_clock::now().time_since_epoch().count())
    {
    }

    template<typename T>
    MultiChannelMap::val_type operator()(Channel<T>& channel) const
    {
        MultiChannelMap::val_type vres;

        Channel<T> res(m_num_samples, channel.width());

        if(m_num_samples > channel.numElements() / 2)
        {
            std::vector<size_t> indices(channel.numElements());
            std::iota(indices.begin(), indices.end(), 0);
            std::shuffle(indices.begin(), indices.end(), std::default_random_engine(m_seed));
            
            for(size_t i=0; i<m_num_samples; i++)
            {
                for(size_t j=0; j<channel.width(); j++)
                {
                    res[i][j] = channel[indices[i]][j];
                }
            }
        } else {
            std::unordered_set<size_t> indices;
            std::srand(m_seed);
            auto eng = std::default_random_engine(m_seed);
            std::uniform_int_distribution<> distr(0, channel.numElements() - 1);

            while(indices.size() < m_num_samples )
            {
                indices.insert(distr(eng));
            }

            size_t i = 0;
            for(const size_t& index : indices)
            {
                for(size_t j=0; j<channel.width(); j++)
                {
                    res[i][j] = channel[index][j];
                }
                i++;
            }
        }

        vres = res;
        return vres;
    }

private:
    const size_t m_num_samples;
    const size_t m_seed;
};

} // namespace manipulators

} // namespace lvr2