3d/image.hh

Go to the documentation of this file.

/* -*- mia-c++  -*-
 *
 * This file is part of MIA - a toolbox for medical image analysis 
 * Copyright (c) Leipzig, Madrid 1999-2017 Gert Wollny
 *
 * MIA is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with MIA; if not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef mia_3d_image_hh
#define mia_3d_image_hh

#include <mia/3d/vectorfield.hh>
#include <mia/3d/orientation.hh>
#include <mia/3d/rot.hh>

#include <mia/2d/image.hh>

#include <mia/3d/valueattributetranslator.hh>
#include <mia/core/pixeltype.hh>
#include <mia/core/filter.hh>


NS_MIA_BEGIN

class EXPORT_3D C3DImage  :  public CAttributedData{
protected:
        C3DImage(const CAttributedData& data, EPixelType type);

        explicit C3DImage(EPixelType type);
        
        
        C3DImage();
public:
        static const char *data_descr;
        
        typedef C3DBounds dimsize_type;

        typedef std::shared_ptr<C3DImage > Pointer;

        virtual  ~C3DImage();

        EPixelType get_pixel_type() const;


        virtual size_t size() const =  0;

        virtual const C3DBounds& get_size() const =  0;

        virtual Pointer clone() const = 0;

        C3DFVector get_voxel_size() const;

        void set_voxel_size(const C3DFVector& voxel);


        C3DFVector get_origin() const;

        void set_origin(const C3DFVector& voxel);
        

        C3DRotation get_rotation() const;

        void set_rotation(const C3DRotation& voxel);

        E3DImageOrientation get_orientation() const;

        void set_orientation(E3DImageOrientation orient);

        virtual std::pair<double, double> get_minmax_intensity() const = 0; 
private:
        EPixelType m_pixel_type;
};

typedef C3DImage::Pointer P3DImage;


typedef std::vector<P3DImage> C3DImageSeries;
typedef std::shared_ptr<C3DImageSeries> P3DImageSeries; 

template <typename T>
class EXPORT_3D T3DImage : public C3DImage {
public:
        typedef C3DImage Super;

        typedef typename T3DDatafield<T>::iterator iterator;
        typedef typename T3DDatafield<T>::const_iterator const_iterator;
        typedef typename T3DDatafield<T>::const_reference const_reference;
        typedef typename T3DDatafield<T>::reference reference;
        typedef typename T3DDatafield<T>::const_pointer const_pointer;
        typedef typename T3DDatafield<T>::pointer pointer;
        typedef typename T3DDatafield<T>::value_type value_type;
        typedef typename T3DDatafield<T>::difference_type difference_type;
        typedef typename T3DDatafield<T>::size_type size_type;
        typedef typename T3DDatafield<T>::range_iterator range_iterator; 
        typedef typename T3DDatafield<T>::const_range_iterator const_range_iterator; 
        typedef typename T3DDatafield<T>::range_iterator_with_boundary_flag range_iterator_with_boundary_flag; 
        typedef typename T3DDatafield<T>::const_range_iterator_with_boundary_flag const_range_iterator_with_boundary_flag; 

        typedef typename T2DDatafield<T>::data_array data_array;
        
        T3DImage(const C3DBounds& size, const T* init_data);

        T3DImage(const C3DBounds& size, const CAttributedData& attr);


        T3DImage(const C3DBounds& size, const data_array& init_data); 
        explicit T3DImage(const C3DBounds& size);

        //T3DImage(const T3DDatafield<T>& size);

        T3DImage(const T3DImage<T>& orig);

        T3DImage(T3DImage<T>&& orig);

        T3DImage& operator = (const T3DImage<T>& orig);

        T3DImage& operator = (T3DImage<T>&& orig);

        explicit T3DImage(const T3DDatafield<T>& orig);

        T3DImage();


        virtual Pointer clone() const;

        void get_data_line_x(int y, int z, std::vector<T>& buffer)const;

        void get_data_line_y(int x, int z, std::vector<T>& buffer)const;

        void get_data_line_z(int x, int y, std::vector<T>& buffer)const;

        void put_data_line_x(int y, int z, const std::vector<T> &buffer);

        void put_data_line_y(int x, int z, const std::vector<T> &buffer);

        void put_data_line_z(int x, int y, const std::vector<T> &buffer);

        T2DImage<T> get_data_plane_xy(size_t  z)const;

        T2DImage<T> get_data_plane_yz(size_t  x)const;

        T2DImage<T> get_data_plane_xz(size_t  y)const;

        void put_data_plane_xy(size_t  z, const T2DImage<T>& p);

        void put_data_plane_yz(size_t  x, const T2DImage<T>& p);

        void put_data_plane_xz(size_t  y, const T2DImage<T>& p);

        
        const_reference operator()(size_t  x, size_t  y, size_t  z) const {
                return m_image(x,y,z);
        }

        reference operator()(size_t  x, size_t  y, size_t  z){
                return m_image(x,y,z);
        }

        const_reference operator()(const C3DBounds& l) const{
                return m_image(l.x,l.y, l.z);
        }

        reference operator()(const C3DBounds& l){
                return m_image(l.x,l.y, l.z);
        }

        const_iterator begin()const {
                return m_image.begin();
        }

        const_iterator end()const {
                return m_image.end();
        }

        range_iterator begin_range(const C3DBounds& begin, const C3DBounds& end) {
                return m_image.begin_range(begin, end); 
        }
        
        range_iterator end_range(const C3DBounds& begin, const C3DBounds& end){
                return m_image.end_range(begin, end); 
        }

        const_range_iterator begin_range(const C3DBounds& begin, const C3DBounds& end)const {
                return m_image.begin_range(begin, end); 
        }

        const_range_iterator end_range(const C3DBounds& begin, const C3DBounds& end) const{
                return m_image.end_range(begin, end); 
        }


        range_iterator_with_boundary_flag begin_range_with_boundary_flags(const C3DBounds& begin, const C3DBounds& end){
                return m_image.begin_range_with_boundary_flags(begin, end); 
        }

        range_iterator_with_boundary_flag end_range_with_boundary_flags(const C3DBounds& begin, const C3DBounds& end){
                return m_image.end_range_with_boundary_flags(begin, end); 
        }


        const_range_iterator_with_boundary_flag begin_range_with_boundary_flags(const C3DBounds& begin, const C3DBounds& end)const{
                return m_image.begin_range_with_boundary_flags(begin, end); 
        }

        const_range_iterator_with_boundary_flag end_range_with_boundary_flags(const C3DBounds& begin, const C3DBounds& end)const{
                return m_image.end_range_with_boundary_flags(begin, end); 
        }

        size_t size() const;

        iterator begin() {
                return m_image.begin();
        }

        iterator end() {
                return m_image.end();
        }

        const_iterator begin_at(size_t x, size_t y, size_t z) const {
                return m_image.begin_at(x,  y, z);
        }

        iterator begin_at(size_t x, size_t y, size_t z) {
                return m_image.begin_at(x,  y,  z);
        }

        const_reference operator[](int i)const
        {
                return m_image[i];
        }

        reference operator[](int i)
        {
                return m_image[i];
        }

        const T3DDatafield<T>& data() const;

        //T3DDatafield<T>& data();

        C3DFVector get_gradient(int index) const
        {
                return m_image.template get_gradient<float>(index);
        }

        virtual const C3DBounds& get_size() const;

        std::pair<double, double> get_minmax_intensity() const; 
private:
        T3DDatafield<T> m_image;
};


template <typename O>
struct FConvert3DImageToPixeltypeO: public TFilter<T3DImage<O> > {

        template <typename T>
        T3DImage<O> operator () (const T3DImage<T> &image) const {
                T3DImage<O> result(image.get_size(), image);
                copy(image.begin(), image.end(), result.begin());
                return result;
        }

        T3DImage<O> operator () (const C3DImage &image) const {
                return filter(*this, image); 
        }

        T3DImage<O> operator () (P3DImage image) const {
                return filter(*this, *image); 
        }
};

typedef FConvert3DImageToPixeltypeO<float> FCopy3DImageToFloatRepn; 


EXPORT_3D C3DFVectorfield get_gradient(const C3DImage& image);


typedef T3DImage<bool> C3DBitImage;

typedef T3DImage<int8_t> C3DSBImage;

typedef T3DImage<uint8_t> C3DUBImage;

typedef T3DImage<int16_t> C3DSSImage;

typedef T3DImage<uint16_t> C3DUSImage;

typedef T3DImage<int32_t> C3DSIImage;

typedef T3DImage<uint32_t> C3DUIImage;

typedef T3DImage<int64_t> C3DSLImage;

typedef T3DImage<uint64_t> C3DULImage;

typedef T3DImage<float> C3DFImage;

typedef T3DImage<double> C3DDImage;

template <>
struct Binder<C3DImage> {
        typedef __bind_all<T3DImage> Derived;
};


NS_MIA_END

#endif