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:
    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 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"