boundary_conditions.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_core_boundary_conditions_hh
#define mia_core_boundary_conditions_hh

#include <mia/core/msgstream.hh>
#include <mia/core/type_traits.hh>
#include <mia/core/factory.hh>
#include <mia/core/product_base.hh>
#include <mia/core/splinekernel.hh>

#include <vector>
#include <memory>

NS_MIA_BEGIN

enum EBoundaryConditions  {
        bc_mirror_on_bounds, 
        bc_repeat, 
        bc_zero, 
        bc_unknown
}; 

class EXPORT_CORE CSplineBoundaryCondition : public CProductBase{
public: 

        typedef CSplineBoundaryCondition plugin_data; 
        
        typedef CSplineBoundaryCondition plugin_type; 

        static const char * const type_descr; 
        
        static const char * const data_descr; 


        typedef std::unique_ptr<CSplineBoundaryCondition> Pointer; 

        CSplineBoundaryCondition(); 


        CSplineBoundaryCondition(const CSplineBoundaryCondition& /*other*/) = delete;

        CSplineBoundaryCondition& operator = (const CSplineBoundaryCondition& /*other*/) = delete; 

        CSplineBoundaryCondition(int width); 

        bool apply(CSplineKernel::VIndex& index, CSplineKernel::VWeight& weights) const;
        
        void set_width(int width); 

        int get_width() const {
                return m_width; 
        }
        
        template <typename T> 
        void filter_line(std::vector<T>& coeff, const std::vector<double>& poles) const;

        void filter_line(std::vector<double>& coeff, const std::vector<double>& poles) const;

        template <typename T> 
        void template_filter_line(std::vector<T>& coeff, const std::vector<double>& poles) const;

        virtual 
                CSplineBoundaryCondition *clone() const __attribute__((warn_unused_result)) = 0 ; 
private:

        virtual void do_apply(CSplineKernel::VIndex& index, CSplineKernel::VWeight& weights) const = 0;
        virtual void test_supported(int npoles) const = 0;
        
        virtual void do_set_width(int width); 

        
        virtual double initial_coeff(const std::vector<double>& coeff, double pole) const = 0;
        virtual double initial_anti_coeff(const std::vector<double>& coeff, double pole)const = 0;


        int m_width; 
}; 



typedef CSplineBoundaryCondition::Pointer PSplineBoundaryCondition; 

extern template class EXPORT_CORE TFactory<CSplineBoundaryCondition>; 

class EXPORT_CORE CSplineBoundaryConditionPlugin: public TFactory<CSplineBoundaryCondition> {
public: 
        CSplineBoundaryConditionPlugin(const char * name); 
private: 
        virtual CSplineBoundaryCondition *do_create() const;
        
        virtual CSplineBoundaryCondition *do_create(int width) const = 0; 

        int m_width; 
}; 



typedef THandlerSingleton<TFactoryPluginHandler<CSplineBoundaryConditionPlugin> > CSplineBoundaryConditionPluginHandler;

template<> 
const char * const TPluginHandler<CSplineBoundaryConditionPlugin>::m_help;

extern template class EXPORT_CORE THandlerSingleton<TFactoryPluginHandler<CSplineBoundaryConditionPlugin> >; 

FACTORY_TRAIT(CSplineBoundaryConditionPluginHandler); 


inline 
PSplineBoundaryCondition produce_spline_boundary_condition(const std::string& descr)
{
        return CSplineBoundaryConditionPluginHandler::instance().produce_unique(descr); 
}


EXPORT_CORE PSplineBoundaryCondition produce_spline_boundary_condition(const std::string& descr, int width)
 __attribute__((deprecated)); 



template <typename T, int size>
struct __dispatch_filter_line {
        static void apply(const CSplineBoundaryCondition& bc, std::vector<T>& coeff, const std::vector<double>& poles); 
}; 

template <typename T, int size>
void __dispatch_filter_line<T, size>::apply(const CSplineBoundaryCondition& bc, std::vector<T>& coeff, 
                                         const std::vector<double>& poles) 
{
        std::vector<double> temp(coeff.size());
        for (int i = 0; i < size; ++i) {
                std::transform(coeff.begin(), coeff.end(), temp.begin(), 
                               [i](const T& x) { return x[i]; }); 
                bc.filter_line(temp, poles); 
                for (size_t j = 0; j < coeff.size(); ++j)
                        coeff[j][i] = temp[j]; 
        }
}

template <typename T>
struct __dispatch_filter_line<T,1> {
        static void apply(const CSplineBoundaryCondition& bc, std::vector<T>& coeff, const std::vector<double>& poles) {
                bc.template_filter_line(coeff, poles); 
        }
}; 


template <typename T> 
void CSplineBoundaryCondition::filter_line(std::vector<T>& coeff, const std::vector<double>& poles) const
{
        typedef atomic_data<T> atom; 
        __dispatch_filter_line<T, atom::size>::apply(*this, coeff, poles); 
}


template <typename T> 
void CSplineBoundaryCondition::template_filter_line(std::vector<T>& coeff, const std::vector<double>& poles) const
{
        std::vector<double> temp(coeff.begin(), coeff.end()); 
        filter_line(temp, poles); 
        std::transform(temp.begin(), temp.end(), coeff.begin(), [](double x) {return static_cast<T>(x);});
}

NS_MIA_END
#endif