2d/transform.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_transform_hh
#define mia_2d_transform_hh

#include <iterator>
#include <memory>
#include <ostream>

#include <mia/core/transformation.hh>
#include <mia/core/filter.hh>
#include <mia/2d/matrix.hh>
#include <mia/2d/image.hh>
#include <mia/2d/interpolator.hh>

NS_MIA_BEGIN


class EXPORT_2D C2DTransformation: public Transformation<C2DImage, C2DInterpolatorFactory> {
public:
        typedef C2DImage Data;
        
        typedef C2DBounds Size; 

        typedef C2DFVector Vector;

        typedef C2DInterpolatorFactory InterpolatorFactory;

        typedef C2DTransformation type; 

        typedef std::shared_ptr<C2DTransformation > Pointer; 

        static const char *data_descr;
        
        static const char *dim_descr; 
protected: 

        class iterator_impl  {
        public: 
                iterator_impl(); 

                iterator_impl(const C2DBounds& pos, const C2DBounds& size); 

                void increment();
                
                void advance(unsigned int delta); 
                
                const C2DFVector&  get_value() const;

                virtual iterator_impl * clone() const __attribute__((warn_unused_result))  = 0; 
                
                bool operator == (const iterator_impl& other) const; 
                
                const C2DBounds& get_pos()const; 

                const C2DBounds& get_size()const; 

                void print(std::ostream& os) const; 
        private:
                virtual const C2DFVector& do_get_value()const = 0; 
                virtual void do_y_increment() = 0; 
                virtual void do_x_increment() = 0; 
                
                C2DBounds m_pos; 
                C2DBounds m_size; 

        }; 
public: 
        class const_iterator : public std::forward_iterator_tag {
        public: 

                typedef std::forward_iterator_tag iterator_category; 

                typedef C2DFVector value_type; 
                
                typedef size_t difference_type; 
                
                typedef C2DFVector *pointer; 

                typedef C2DFVector& reference; 

                const_iterator(); 

                const_iterator(iterator_impl * holder); 


                const_iterator& operator = (const const_iterator& other); 

                const_iterator(const const_iterator& other); 


                const_iterator& operator ++(); 

                const_iterator operator ++(int); 

                const_iterator& operator += (unsigned int delta); 

                const C2DFVector& operator *() const;
                
                const C2DFVector  *operator ->() const;

                const C2DBounds& pos() const; 

                const C2DBounds& get_size() const; 

                void print(std::ostream& os) const; 
        private: 
                std::unique_ptr<iterator_impl> m_holder;

                friend EXPORT_2D bool operator == (const C2DTransformation::const_iterator& a, 
                                                   const C2DTransformation::const_iterator& b); 

        }; 

        using Transformation<C2DImage, C2DInterpolatorFactory>::operator ();

        C2DTransformation(const C2DInterpolatorFactory& ipf);

        void set_creator_string(const std::string& s); 

        const std::string& get_creator_string()const; 

        virtual C2DTransformation *clone() const __attribute__((warn_unused_result));

        virtual C2DTransformation *invert() const __attribute__((warn_unused_result))  = 0;

        virtual const_iterator begin() const = 0; 

        virtual const_iterator end() const = 0; 

        Pointer upscale(const C2DBounds& size) const;

        virtual void update(float step, const C2DFVectorfield& a) = 0;

        virtual size_t degrees_of_freedom() const = 0;

        virtual void set_identity() = 0;

        virtual C2DFMatrix derivative_at(const C2DFVector& x) const = 0;

        virtual C2DFMatrix derivative_at(int x, int y) const = 0;

        virtual void translate(const C2DFVectorfield& gradient, CDoubleVector& params) const = 0;

        virtual CDoubleVector get_parameters() const = 0;

        virtual void set_parameters(const CDoubleVector& params) = 0;

        virtual float get_max_transform() const = 0;

        virtual const C2DBounds& get_size() const = 0;

        virtual float pertuberate(C2DFVectorfield& v) const = 0;

        virtual C2DFVector apply(const C2DFVector& x) const __attribute__((deprecated)){
                return get_displacement_at(x); 
        }

        virtual C2DFVector get_displacement_at(const C2DFVector& x) const =0; 
        virtual C2DFVector operator () (const C2DFVector& x) const = 0;

        virtual float get_jacobian(const C2DFVectorfield& v, float delta) const = 0;


        virtual bool refine(); 

        /* Attributes */
        static constexpr const char *input_spacing_attr = "in-pixel-spacing"; 

        static constexpr const char *output_spacing_attr = "out-pixel-spacing"; 


        virtual C2DBounds get_minimal_supported_image_size() const; 

private: 

        virtual Pointer do_upscale(const C2DBounds& size) const = 0;

        std::string m_creator_string;  
        virtual C2DTransformation *do_clone() const __attribute__((warn_unused_result)) = 0;


        P2DImage do_transform(const C2DImage& input, const C2DInterpolatorFactory& ipf) const;

};

typedef C2DTransformation::Pointer P2DTransformation;



inline C2DTransformation::const_iterator operator + (C2DTransformation::const_iterator i, size_t delta) 
{
        i += delta; 
        return i; 
}

inline std::ostream& operator << (std::ostream& os, 
                                  const C2DTransformation::const_iterator& i) 
{
        i.print(os); 
        return os; 
}

EXPORT_2D bool operator != (const C2DTransformation::const_iterator& a, 
                            const C2DTransformation::const_iterator& b); 


NS_MIA_END

#endif