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;
        unsigned int step_sizes[4];
        data_view_base(const data_format* _format, unsigned int _dim, 
                                           const unsigned int* _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;
        unsigned int 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 int _dim, const unsigned int* _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(int 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(int i, int 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(int i, int j, int 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(int i, int j, int k, int 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(int ci) const { 
                return format->get<S>(ci, data_ptr);
        }
        template <typename S> S get(int ci, int i) const { 
                return format->get<S>(ci, get_ptr<cgv::type::func::drop_pointer<P>::type>(i));
        }
        template <typename S> S get(int ci, int i, int j) const { 
                return format->get<S>(ci, get_ptr<cgv::type::func::drop_pointer<P>::type>(i, j));
        }
        template <typename S> S get(int ci, int i, int j, int k) const { 
                return format->get<S>(ci, get_ptr<cgv::type::func::drop_pointer<P>::type>(i,j,k));
        }
        template <typename S> S get(int ci, int i, int j, int k, int l) const { 
                return format->get<S>(ci, get_ptr<cgv::type::func::drop_pointer<P>::type>(i, j, k, l));
        }
        D operator () (unsigned int i) const;
        D operator () (unsigned int i, unsigned int j) const;
        D operator () (unsigned int i, unsigned int j, unsigned int k) const;
        D operator () (unsigned int i, unsigned int j, unsigned int k, unsigned int 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, int 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, int 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, int 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, int n=1) const { return static_cast<typename cgv::type::func::transfer_const<P,S*>::type>(static_cast<P>(ptr)+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 unsigned int* _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& operator = (const data_view& dv);
        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 int _dim, const unsigned int* _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>