2d/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_2d_2dimage_hh
#define mia_2d_2dimage_hh

#include <mia/core/attributes.hh>
#include <mia/core/pixeltype.hh>
#include <mia/core/filter.hh>
#include <mia/core/msgstream.hh>
#include <mia/core/tools.hh>
#include <mia/core/type_traits.hh>
#include <mia/2d/vectorfield.hh>

NS_MIA_BEGIN

#define ATTR_IMAGE_KMEANS_CLASSES "kmeans"


class EXPORT_2D C2DImage: public CAttributedData {
public:
        static const char *data_descr;

        typedef C2DBounds dimsize_type;

        typedef std::shared_ptr<C2DImage > Pointer;

        virtual  ~C2DImage();

        EPixelType get_pixel_type() const;

        const C2DBounds& get_size() const;

        C2DFVector get_pixel_size() const;

        void set_pixel_size(const C2DFVector& pixel);


        C2DFVector get_origin() const;

        void set_origin(const C2DFVector& origin);

        virtual C2DImage* clone() const __attribute__((warn_unused_result))  = 0;

        virtual std::pair<double, double> get_minmax_intensity() const = 0; 

        virtual void make_single_ref() __attribute__((deprecated)) = 0; 
        
 protected:
        C2DImage(C2DImage&& other);
        C2DImage& operator = (C2DImage&& other);
        
        C2DImage(const C2DImage& other) = default; 


        C2DImage& operator = (const C2DImage& other) = default; 
        
        
        C2DImage(const C2DBounds& size, EPixelType type);
        
        C2DImage(const CAttributedData& attributes, const C2DBounds& size, EPixelType type);
        
        C2DImage();
        
private:
        C2DBounds m_size;
        EPixelType m_pixel_type;
};

typedef C2DImage::Pointer P2DImage;

typedef std::vector<P2DImage> C2DImageSeries;

typedef std::shared_ptr<C2DImageSeries> P2DImageSeries;

typedef std::vector<C2DImageSeries> C2DImageSeriesGroup; 
typedef std::map<std::string, C2DImageSeriesGroup> C2DImageGroupedSeries; 


template <typename T>
class EXPORT_2D T2DImage : public C2DImage {
public:
        typedef C2DImage Super;

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

        typedef typename T2DDatafield<T>::data_array data_array;


        T2DImage(const C2DBounds& size, const T* init_data);

        T2DImage(const C2DBounds& size, const std::vector<T>& init_data);
        T2DImage(const C2DBounds& size, const CAttributedData& attr);

        T2DImage(const C2DBounds& size);

        T2DImage(const T2DImage& orig);

        T2DImage(T2DImage&& orig);

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

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

                
        T2DImage(const T2DDatafield<T>& orig);

        T2DImage(const T2DDatafield<T>& orig, const CAttributedData& attr);
        
        T2DImage();

        virtual C2DImage* clone() const __attribute__((warn_unused_result));
        
        const_reference operator()(size_t  x, size_t  y) const {
                return m_image(x,y);
        }
        
        reference operator()(size_t  x, size_t  y){
                return m_image(x,y);
        }
        
        const_reference operator[](size_t  idx) const {
                return m_image[idx];
        }
        
        reference operator[](size_t  idx){
                return m_image[idx];
        }
        
        const_reference operator()(const C2DBounds& l) const{
                return m_image(l.x,l.y);
        }
        
        reference operator()(const C2DBounds& l){
                return m_image(l.x,l.y);
        }

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

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

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

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

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

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

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

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

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

        size_t size() const;

        const T2DDatafield<T>& data() const;

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

        void get_data_line_y(size_t x, std::vector<T>& buffer) const;
        
        void put_data_line_x(size_t y, const std::vector<T>& buffer);

        void put_data_line_y(size_t x, const std::vector<T>& buffer);
        
        C2DFVector get_gradient(size_t idx) const;
        
        C2DFVector get_gradient(const C2DFVector& p) const;

        std::pair<double, double> get_minmax_intensity() const;

        void make_single_ref() __attribute__((deprecated)); 
private:
        T2DDatafield<T> m_image;
};

class CImageComparePrinter: public TFilter<int> {
public:
        template <typename T, typename S>
        int operator () (const T2DImage<T>& src, const T2DImage<S>& ref) const {
                typename T2DImage<T>::const_iterator si = src.begin();
                typename T2DImage<T>::const_iterator se = src.end();
                typename T2DImage<S>::const_iterator ri = ref.begin();

                while (si != se)
                        cvdebug() << *si++ << " expect " << *ri++ << "\n";
                return 0;
        }
};

template <typename S> 
struct plugin_data_type<T2DImage<S> > {
        typedef C2DImage type; 
}; 

EXPORT_2D bool operator == (const C2DImage& a, const C2DImage& b);

inline bool operator != (const C2DImage& a, const C2DImage& b)
{
        return ! (a == b );
}


EXPORT_2D C2DFVectorfield get_gradient(const C2DImage& image);

class CopyC2DImageToP2DImage {
public: 
        template <typename T>
        P2DImage operator () (const T2DImage<T>& image) const {
                return P2DImage(new T2DImage<T>(image)); 
        }
};

typedef T2DImage<bool> C2DBitImage;

typedef T2DImage<int8_t> C2DSBImage;

typedef T2DImage<uint8_t> C2DUBImage;

typedef T2DImage<int16_t> C2DSSImage;

typedef T2DImage<uint16_t> C2DUSImage;

typedef T2DImage<int32_t> C2DSIImage;

typedef T2DImage<uint32_t> C2DUIImage;

typedef T2DImage<int64_t> C2DSLImage;

typedef T2DImage<uint64_t> C2DULImage;

typedef T2DImage<float> C2DFImage;

typedef T2DImage<double> C2DDImage;

template <>
struct Binder<C2DImage> {
        typedef __bind_all<T2DImage> Derived;
};

//@endcond INTERNAL 

template <typename O>
struct FConvert2DImageToPixeltypeO: public TFilter<T2DImage<O> > {

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

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

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


typedef FConvert2DImageToPixeltypeO<float> FCopy2DImageToFloatRepn; 


NS_MIA_END

#endif