volume.h

#pragma once
 
#include <cgv/math/fvec.h>
#include <cgv/media/axis_aligned_box.h>
#include <cgv/data/data_view.h>
#include <cgv/type/info/type_id.h>
 
#include "../lib_begin.h"
 
namespace cgv {
    namespace media {
        namespace volume {
 
            class CGV_API volume
            {
            public:
                typedef float coord_type;
                typedef cgv::math::fvec<int,3> index_type;
                typedef cgv::math::fvec<int,3> dimension_type;
                typedef cgv::math::fvec<coord_type,3> point_type;
                typedef cgv::math::fvec<coord_type,3> extent_type;
                typedef cgv::media::axis_aligned_box<coord_type,3> box_type;
            protected:
                cgv::data::data_format df;
                cgv::data::data_view dv;
                extent_type extent;
            public:
                volume();
                volume(const volume& V);
                ~volume() { clear(); }
                bool empty() const { return get_dimensions() == dimension_type(0, 0, 0); }
                void clear() { dv = cgv::data::data_view(); df = cgv::data::data_format(); }
                const cgv::data::data_format& get_format() const { return df; }
                cgv::data::data_format& get_format() { return df; }
 
                cgv::type::info::TypeId get_component_type() const { return df.get_component_type(); }
                cgv::data::ComponentFormat get_component_format() const { return df.get_standard_component_format(); }
                void set_component_format(cgv::data::ComponentFormat cf) { df.set_component_format(cgv::data::component_format(df.get_component_type(), cf)); }
                void set_component_type(cgv::type::info::TypeId type_id) { df.set_component_type(type_id); }
                void set_component_format(const std::string& format) { df.set_component_format(cgv::data::component_format(format)); }
                unsigned get_nr_components()  const { return df.get_nr_components(); }
                unsigned get_component_size() const { return cgv::type::info::get_type_size(get_component_type()); }
                unsigned get_voxel_size() const { return df.get_component_format().get_entry_size(); }
                size_t get_row_size() const { return df.get_width() * get_voxel_size(); }
                size_t get_slice_size() const { return df.get_height() * get_row_size(); }
                size_t get_size() const { return get_voxel_size() * get_nr_voxels(); }
 
                virtual dimension_type get_dimensions() const;
                size_t get_nr_voxels() const;
                virtual void resize(const dimension_type& S);
 
                box_type get_box() const;
                const extent_type& get_extent() const { return extent; }
                extent_type& ref_extent() { return extent; }
                extent_type get_spacing() const;
 
                const cgv::data::data_view& get_data_view() const { return dv; }
                cgv::data::data_view& get_data_view() { return dv; }
                template <typename T>
                const T* get_data_ptr() const { return dv.get_ptr<T>(); }
                template <typename T>
                T* get_data_ptr() { return dv.get_ptr<T>(); }
                template <typename T>
                const T* get_slice_ptr(unsigned k) const { return dv.get_ptr<T>(k); }
                template <typename T>
                T* get_slice_ptr(unsigned k) { return dv.get_ptr<T>(k); }
                template <typename T>
                const T* get_row_ptr(unsigned j, unsigned k) const { return dv.get_ptr<T>(k, j); }
                template <typename T>
                T* get_row_ptr(unsigned j, unsigned k) { return dv.get_ptr<T>(k, j); }
                template <typename T>
                const T* get_voxel_ptr(unsigned i, unsigned j, unsigned k) const { return dv.get_ptr<T>(k, j, i); }
                template <typename T>
                T* get_voxel_ptr(unsigned i, unsigned j, unsigned k) { return dv.get_ptr<T>(k, j, i); }
                template <typename T>
                T get_voxel_component(unsigned i, unsigned j, unsigned k, unsigned ci = 0) { return dv.get<T>(ci, k, j, i); }
 
                bool add_new_component(data::data_view& component_dv);
                bool replace_component(unsigned i, data::data_view& component_dv);
            };
        }
    }
}
 
#include <cgv/config/lib_end.h>