data_view.h

#pragma once
 
#include <cgv/type/info/type_ptr.h>
#include <cgv/type/func/transfer_const.h>
#include <cgv/type/func/drop_pointer.h>
#include <cgv/data/data_format.h>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace data {
 
class CGV_API data_view_base
{
protected:
    const data_format* format;
    bool owns_format;
    unsigned int dim;
    size_t step_sizes[4];
    data_view_base(const data_format* _format, unsigned int _dim, const size_t* _step_sizes);
public:
    data_view_base(const data_format* _format = 0);
    virtual ~data_view_base();
    void manage_format(bool enable = true);
    const data_format* get_format() const;
    void set_format(const data_format* _format);
    unsigned int get_dim() const;
    size_t get_step_size(unsigned int dim) const;
};
 
template <class D, typename P = unsigned char*>
class CGV_API data_view_impl : public data_view_base
{
protected:
    P data_ptr;
    data_view_impl(const data_format* _format, P _data_ptr, unsigned _dim, const size_t* _step_sizes);
public:
    data_view_impl(const data_format* _format = 0, typename cgv::type::func::transfer_const<P,void*>::type _data_ptr = 0);
    bool empty() const;
    template <typename S>
    typename cgv::type::func::transfer_const<P,S*>::type get_ptr() const { 
        return (typename cgv::type::func::transfer_const<P,S*>::type)(data_ptr); 
    }
    template <typename S>
    typename cgv::type::func::transfer_const<P, S*>::type get_ptr(size_t i) const {
        return (typename cgv::type::func::transfer_const<P, S*>::type)(data_ptr + i*step_sizes[0]);
    }
    template <typename S>
    typename cgv::type::func::transfer_const<P, S*>::type get_ptr(size_t i, size_t j) const {
        return (typename cgv::type::func::transfer_const<P, S*>::type)(data_ptr + i*step_sizes[0] + j*step_sizes[1]);
    }
    template <typename S>
    typename cgv::type::func::transfer_const<P, S*>::type get_ptr(size_t i, size_t j, size_t k) const {
        return (typename cgv::type::func::transfer_const<P, S*>::type)(data_ptr + i*step_sizes[0] + j*step_sizes[1] + k*step_sizes[2]);
    }
    template <typename S>
    typename cgv::type::func::transfer_const<P, S*>::type get_ptr(size_t i, size_t j, size_t k, size_t l) const {
        return (typename cgv::type::func::transfer_const<P, S*>::type)(data_ptr + i*step_sizes[0] + j*step_sizes[1] + k*step_sizes[2] + l*step_sizes[3]);
    }
    template <typename S>
    S get(unsigned ci) const {
        return format->get<S>(ci, data_ptr);
    }
    template <typename S> S get(unsigned ci, size_t i) const {
        return format->get<S>(ci, get_ptr<typename cgv::type::func::drop_pointer<P>::type>(i));
    }
    template <typename S> S get(unsigned ci, size_t i, size_t j) const {
        return format->get<S>(ci, get_ptr<typename cgv::type::func::drop_pointer<P>::type>(i, j));
    }
    template <typename S> S get(unsigned ci, size_t i, size_t j, size_t k) const {
        return format->get<S>(ci, get_ptr<typename cgv::type::func::drop_pointer<P>::type>(i, j, k));
    }
    template <typename S> S get(unsigned ci, size_t i, size_t j, size_t k, size_t l) const {
        return format->get<S>(ci, get_ptr<typename cgv::type::func::drop_pointer<P>::type>(i, j, k, l));
    }
    D operator () (size_t i) const;
    D operator () (size_t i, size_t j) const;
    D operator () (size_t i, size_t j, size_t k) const;
    D operator () (size_t i, size_t j, size_t k, size_t l) const;
 
    D permute(const std::string& permutation) const;
    D transpose() const { return permute("ji"); }
 
    template <typename S>
    typename cgv::type::func::transfer_const<P,S*>::type 
        step_i(S* ptr, std::ptrdiff_t n=1) const { return static_cast<typename cgv::type::func::transfer_const<P,S*>::type>(static_cast<P>(ptr)+n*step_sizes[0]); }
    template <typename S>
    typename cgv::type::func::transfer_const<P,S*>::type 
        step_j(S* ptr, std::ptrdiff_t n=1) const { return static_cast<typename cgv::type::func::transfer_const<P,S*>::type>(static_cast<P>(ptr)+n*step_sizes[1]); }
    template <typename S>
    typename cgv::type::func::transfer_const<P,S*>::type 
        step_k(S* ptr, std::ptrdiff_t n=1) const { return static_cast<typename cgv::type::func::transfer_const<P,S*>::type>(static_cast<P>(ptr)+n*step_sizes[2]); }
    template <typename S>
    typename cgv::type::func::transfer_const<P,S*>::type 
        step_l(S* ptr, std::ptrdiff_t n=1) const { return static_cast<typename cgv::type::func::transfer_const<P,S*>::type>(static_cast<P>(ptr)+n*step_sizes[3]); }
};
 
class CGV_API const_data_view;
 
class CGV_API data_view : public data_view_impl<data_view, unsigned char*>
{
protected:
    friend class data_view_impl<data_view, unsigned char*>;
    friend class const_data_view;
    bool owns_ptr;
    data_view(const data_format* _format, unsigned char* _data_ptr, 
                 unsigned int _dim, const size_t* _step_sizes);
public:
    data_view();
    ~data_view();
    data_view(const data_format* _format);
    data_view(const data_format* _format, void* _data_ptr);
    data_view(const data_format* _format, unsigned char* _data_ptr, bool manage_ptr);
    data_view(const data_view& other) : data_view(other.format) {
        const cgv::type::uint8_type* src_ptr = other.get_ptr<cgv::type::uint8_type>();
        cgv::type::uint8_type* dst_ptr = get_ptr<cgv::type::uint8_type>();
        memcpy(dst_ptr, src_ptr, other.format->get_nr_bytes());
    }
    data_view& operator = (const data_view& dv);
    data_view copy() {
        return data_view(*this);
    }
    void set_ptr(unsigned char* ptr, bool manage_ptr);
    void set_ptr(void* ptr);
    template <typename T>
    bool set(int ci, const T& v) {
        return format->set(ci, data_ptr, v);
    }
    void reflect_horizontally();
    static bool compose(data_view& composed_dv, const std::vector<data_view>& dvs);
    static bool combine_components(data_view& dv, const std::vector<data_view>::iterator first, const std::vector<data_view>::iterator last);
};
 
class CGV_API const_data_view : public data_view_impl<const_data_view, const unsigned char*>
{
protected:
    friend class data_view_impl<const_data_view, const unsigned char*>;
    const_data_view(const data_format* _format, const unsigned char* _data_ptr, 
                         unsigned _dim, const size_t* _step_sizes);
public:
    const_data_view();
    const_data_view(const data_view& dv);
    const_data_view(const data_format* _format, const void* _data_ptr);
    const_data_view& operator = (const const_data_view& dv);
    void set_ptr(const void* ptr);
};
 
    }
}
 
#include <cgv/config/lib_end.h>