3d/interpolator.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_3d_interpolator_hh
#define mia_3d_interpolator_hh


#include <vector>
#include <mia/core/splinekernel.hh>
#include <mia/core/boundary_conditions.hh>
#include <mia/3d/image.hh>
#include <mia/core/parallel.hh>

NS_MIA_BEGIN


template <typename T>
class  EXPORT_3D T3DInterpolator  {
public:
        
        virtual  ~T3DInterpolator(){}

        virtual T operator () (const C3DFVector& x) const = 0;

};

template <class U>
struct coeff_map<T3DVector<U> > {
        typedef T3DVector<U> value_type;
        typedef C3DDVector   coeff_type;
};

struct C3DWeightCache {
        CSplineKernel::SCache x; 
        CSplineKernel::SCache y; 
        CSplineKernel::SCache z; 
        
        C3DWeightCache(int kernel_size, 
                       const CSplineBoundaryCondition& xbc, 
                       const CSplineBoundaryCondition& ybc, 
                       const CSplineBoundaryCondition& zbc); 
}; 

template <class T>
class EXPORT_3D T3DConvoluteInterpolator: public T3DInterpolator<T> {
public:
        typedef T3DDatafield< typename coeff_map< T >::coeff_type > TCoeff3D;
        
        T3DConvoluteInterpolator(const T3DDatafield<T>& data, PSplineKernel kernel); 
        
        T3DConvoluteInterpolator(const T3DDatafield<T>& data, PSplineKernel kernel, 
                                 const CSplineBoundaryCondition& xbc,  
                                 const CSplineBoundaryCondition& ybc, 
                                 const CSplineBoundaryCondition& zbc);
        
        ~T3DConvoluteInterpolator();

        C3DWeightCache create_cache() const; 

        T  operator () (const C3DFVector& x, C3DWeightCache& cache) const;

        T  operator () (const C3DFVector& x) const;

        
        const TCoeff3D& get_coefficients() const {
                return m_coeff; 
        }

protected:
        typedef std::vector< typename TCoeff3D::value_type > coeff_vector;
private:

        void prefilter(const T3DDatafield<T>& image); 

        TCoeff3D m_coeff;
        C3DBounds m_size2;
        PSplineKernel m_kernel;
        PSplineBoundaryCondition m_xbc; 
        PSplineBoundaryCondition m_ybc; 
        PSplineBoundaryCondition m_zbc; 

        typename T3DDatafield<T>::value_type m_min;
        typename T3DDatafield<T>::value_type m_max;
        
        mutable CMutex m_cache_lock; 
        mutable C3DWeightCache m_cache; 
};


class EXPORT_3D C3DInterpolatorFactory {
public:
        

        C3DInterpolatorFactory(const std::string& kernel, const std::string& boundary_conditions);

        C3DInterpolatorFactory(PSplineKernel kernel, const CSplineBoundaryCondition& boundary_conditions);

        C3DInterpolatorFactory(PSplineKernel kernel, 
                               const CSplineBoundaryCondition&xbc,  
                               const CSplineBoundaryCondition&ybc, 
                               const CSplineBoundaryCondition&zbc);

        C3DInterpolatorFactory(PSplineKernel kernel, const std::string& bc); 

        
        C3DInterpolatorFactory(const C3DInterpolatorFactory& o);

        C3DInterpolatorFactory& operator = ( const C3DInterpolatorFactory& o);

        virtual ~C3DInterpolatorFactory();

        template <class T>
        T3DConvoluteInterpolator<T> *create(const T3DDatafield<T>& src) const
                __attribute__ ((warn_unused_result));
        
        PSplineKernel get_kernel() const; 
private:
        PSplineKernel m_kernel;
        PSplineBoundaryCondition m_xbc; 
        PSplineBoundaryCondition m_ybc; 
        PSplineBoundaryCondition m_zbc; 
};

// implementation

template <class T>
T3DConvoluteInterpolator<T> *C3DInterpolatorFactory::create(const T3DDatafield<T>& src) const
{
        return new T3DConvoluteInterpolator<T>(src, m_kernel, *m_xbc, *m_ybc, *m_zbc);
}

typedef std::shared_ptr<C3DInterpolatorFactory> P3DInterpolatorFactory;

NS_MIA_END

#endif