splinekernel.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_splinekernel_hh
#define mia_core_splinekernel_hh

#include <vector>
#include <memory>
#include <cmath>
#include <mia/core/defines.hh>
#include <mia/core/dictmap.hh>
#include <mia/core/factory.hh>
#include <mia/core/product_base.hh>

NS_MIA_BEGIN


class CSplineBoundaryCondition; 

class EXPORT_CORE CSplineKernel : public CProductBase{
public:

        typedef CSplineKernel plugin_data; 
        typedef CSplineKernel plugin_type; 

        static const char *type_descr; 

        static const char *data_descr; 

        typedef std::vector<double> VWeight; 

        typedef std::vector<int> VIndex; 

        struct SCache {
                SCache(size_t s, const CSplineBoundaryCondition& bc, bool am); 

                void reset(); 

                double x; 
                
                int start_idx; 

                int index_limit; 
                
                VWeight weights; 
                
                VIndex index; 

                const CSplineBoundaryCondition& boundary_condition; 
                
                bool is_flat; 

                bool never_flat; 
        }; 

        CSplineKernel(int degree, double shift, EInterpolation type);

        virtual ~CSplineKernel();

        void operator () (double x, VWeight& weight, VIndex& index)const;

        void operator () (double x, SCache& cache)const;

        void get_cached(double x, SCache& cache)const;

        void get_uncached(double x, SCache& cache)const;

        void derivative(double x, VWeight& weight, VIndex& index)const;
        
        void derivative(double x, VWeight& weight, VIndex& index, int order)const;
        
        int get_indices(double x, VIndex& index) const;

        virtual void get_weights(double x, VWeight& weight) const = 0;

        virtual void get_derivative_weights(double x, VWeight& weight) const = 0;

        virtual void get_derivative_weights(double x, VWeight& weight, int order) const = 0;


        virtual double get_weight_at(double x, int order) const;
        
        EInterpolation get_type() const; 

        const std::vector<double>& get_poles() const;

        size_t size() const;


        double get_nonzero_radius() const;

        int get_active_halfrange()const; 

        int get_start_idx_and_value_weights(double x, VWeight& weights) const; 

        int get_start_idx_and_derivative_weights(double x, VWeight& weights) const; 

protected:
        void add_pole(double x);

private:
        int get_start_idx(double x) const; 

        void fill_index(short i, VIndex& index) const; 

        
        size_t m_half_degree;
        
        double m_shift;
        
        std::vector<double> m_poles;

        size_t m_support_size;
        
        EInterpolation m_type; 
        std::vector<short> m_indices;
        
};

typedef std::shared_ptr<CSplineKernel> PSplineKernel;

typedef TFactory<CSplineKernel> CSplineKernelPlugin; 


template<>  const char * const 
TPluginHandler<TFactory<CSplineKernel>>::m_help; 
typedef THandlerSingleton<TFactoryPluginHandler<CSplineKernelPlugin> > CSplineKernelPluginHandler;

inline PSplineKernel produce_spline_kernel(const std::string& descr) 
{
        return CSplineKernelPluginHandler::instance().produce(descr); 
}

FACTORY_TRAIT(CSplineKernelPluginHandler); 

template <>
struct __cache_policy<CSplineKernelPlugin> {
        static  bool apply() {
                return true; 
        }
}; 

template <typename T>
struct max_hold_type {
        typedef double type;
};

template <class T>
struct coeff_map {
        typedef T     value_type;
        typedef double coeff_type;
};
template <>
struct coeff_map<float> {
        typedef float value_type;
        typedef float coeff_type;
};


inline size_t CSplineKernel::size()const
{
        return m_support_size;
}


double  EXPORT_CORE integrate2(const CSplineKernel& spline, double s1, double s2, int d1, int d2, double n, double x0, double L);


NS_MIA_END

#endif