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