Kernels.h

#pragma once
 
#include "forward.h"
 
#include <cmath>
#include <vector>
 
#include <isce3/math/Bessel.h>
 
namespace isce3 { namespace core {

template<typename T>
class Kernel {
public:
    using value_type = T;
 
    Kernel(double width) : _halfwidth(fabs(width / 2.0)) {}

    virtual ~Kernel() {}

    virtual T operator()(double x) const = 0;

    double width() const { return _halfwidth * 2; }
 
protected:
    double _halfwidth;
};

template<typename T>
class BartlettKernel : public Kernel<T> {
public:
    BartlettKernel(double width) : Kernel<T>(width) {}
 
    T operator()(double x) const override;
};

template<typename T>
class LinearKernel : public BartlettKernel<T> {
public:
    LinearKernel() : BartlettKernel<T>(2.0) {}
};

template<typename T>
class KnabKernel : public Kernel<T> {
public:
    KnabKernel(double width, double bandwidth)
        : Kernel<T>(width), _bandwidth(bandwidth)
    {}
 
    T operator()(double x) const override;

    double bandwidth() const { return _bandwidth; }
 
private:
    double _bandwidth;
};

template<typename T>
class NFFTKernel : public Kernel<T> {
public:
    NFFTKernel(int m, int n, int fft_size);
 
    T operator()(double x) const override;
 
private:
    int _m;
    int _n;
    int _fft_size;
    T _scale;
    T _b;
};

template<typename T>
class AzimuthKernel : public Kernel<T> {
public:
    AzimuthKernel(double scale) : Kernel<T>(2 * scale) {}  // non-zero on 2L
 
    T operator()(double x) const override;
};

template<typename T>
class TabulatedKernel : public Kernel<T> {
public:
    template<typename Tin>
    TabulatedKernel(const Kernel<Tin>& kernel, int n);
 
    T operator()(double x) const override;
 
    const std::vector<T>& table() const { return _table; }
 
private:
    std::vector<T> _table;
    int _imax;
    T _1_dx;
};

template<typename T>
class ChebyKernel : public Kernel<T> {
public:
    template<typename Tin>
    ChebyKernel(const Kernel<Tin>& kernel, int n);
 
    T operator()(double x) const override;
 
    const std::vector<T>& coeffs() const { return _coeffs; }
 
private:
    std::vector<T> _coeffs;
    T _scale;
};
 
}} // namespace isce3::core
 
#include "Kernels.icc"