Interpolator.h

//
// Author: Joshua Cohen, Bryan Riel, Liang Yu
// Copyright 2017-2018
//

#pragma once

#include "forward.h"

#include <valarray>

#include "Constants.h"
#include "EMatrix.h"
#include "Matrix.h"

template<typename U>
class isce3::core::Interpolator {

protected:
    using Map = typename Eigen::Map<const EArray2D<U>>;

    // Public interface
public:
    virtual ~Interpolator() {}

protected:
    virtual U interp_impl(double x, double y, const Map& map) const = 0;

public:

    U interpolate(double x, double y, const Map& map) const
    {
        return interp_impl(x, y, map);
    }

    U interpolate(double x, double y, const Matrix<U>& z) const
    {
        return interp_impl(x, y, z.map());
    }

    U interpolate(double x, double y, std::valarray<U>& z_data,
                  size_t width) const
    {
        const Map z {&z_data[0],
                     static_cast<Eigen::Index>(z_data.size() / width),
                     static_cast<Eigen::Index>(width)};
        return interp_impl(x, y, z);
    }

    U interpolate(double x, double y, std::vector<U>& z_data,
                  size_t width) const
    {
        const Map z {&z_data[0],
                     static_cast<Eigen::Index>(z_data.size() / width),
                     static_cast<Eigen::Index>(width)};
        return interp_impl(x, y, z);
    }

    dataInterpMethod method() const { return _method; }

    // Protected constructor and data to be used by derived classes
protected:
    inline Interpolator(dataInterpMethod method) : _method {method} {}
    dataInterpMethod _method;
};

template<typename U>
class isce3::core::BilinearInterpolator : public isce3::core::Interpolator<U> {

    using super_t = Interpolator<U>;
    using typename super_t::Map;

    U interp_impl(double x, double y, const Map& z) const override;

public:
    BilinearInterpolator() : super_t {BILINEAR_METHOD} {}

    // Inherit overloads for other datatypes
    using super_t::interpolate;
};

template<typename U>
class isce3::core::BicubicInterpolator : public isce3::core::Interpolator<U> {

    using super_t = Interpolator<U>;
    using typename super_t::Map;

    U interp_impl(double x, double y, const Map& z) const override;

public:
    BicubicInterpolator() : super_t {BICUBIC_METHOD} {}

    // Inherit overloads for other datatypes
    using super_t::interpolate;
};

template<typename U>
class isce3::core::NearestNeighborInterpolator :
    public isce3::core::Interpolator<U> {

    using super_t = Interpolator<U>;
    using typename super_t::Map;

    U interp_impl(double x, double y, const Map& z) const override;

public:
    NearestNeighborInterpolator() : super_t {NEAREST_METHOD} {}

    // Inherit overloads for other datatypes
    using super_t::interpolate;
};

template<typename U>
class isce3::core::Spline2dInterpolator : public isce3::core::Interpolator<U> {

    using super_t = Interpolator<U>;
    using typename super_t::Map;

public:
    Spline2dInterpolator(size_t order);

    U interp_impl(double x, double y, const Map& z) const override;

    // Inherit overloads for other datatypes
    using super_t::interpolate;

    // Data members
private:
    size_t _order;

    // Utility spline functions
private:
    void _initSpline(const std::valarray<U>&, int, std::valarray<U>&,
                     std::valarray<U>&) const;

    U _spline(double, const std::valarray<U>&, int,
              const std::valarray<U>&) const;
};

template<typename U>
class isce3::core::Sinc2dInterpolator : public isce3::core::Interpolator<U> {

    using super_t = Interpolator<U>;
    using typename super_t::Map;

    U interp_impl(double x, double y, const Map& z) const override;

public:
    Sinc2dInterpolator(int sincLen, int sincSub);

    // Inherit overloads for other datatypes
    using super_t::interpolate;

private:
    // Compute sinc coefficients
    void _sinc_coef(double beta, double relfiltlen, int decfactor,
                    double pedestal, int weight,
                    std::valarray<double>& filter) const;

    // Evaluate sinc
    U _sinc_eval_2d(const Map& z, int intpx, int intpy, double frpx,
                    double frpy) const;

private:
    Matrix<double> _kernel;
    int _kernelLength, _kernelWidth, _sincHalf;
};

// Extra interpolation and utility functions
namespace isce3 { namespace core {

template<typename U>
inline Interpolator<U>*
createInterpolator(dataInterpMethod method, size_t order = 6,
                   int sincLen = SINC_LEN, int sincSub = SINC_SUB)
{
    if (method == BILINEAR_METHOD) {
        return new BilinearInterpolator<U>();
    } else if (method == BICUBIC_METHOD) {
        return new BicubicInterpolator<U>();
    } else if (method == BIQUINTIC_METHOD) {
        return new Spline2dInterpolator<U>(order);
    } else if (method == NEAREST_METHOD) {
        return new NearestNeighborInterpolator<U>();
    } else if (method == SINC_METHOD) {
        return new Sinc2dInterpolator<U>(sincLen, sincSub);
    } else {
        return new BilinearInterpolator<U>();
    }
}

// Sinc evaluation in 1D
template<class U, class V>
U sinc_eval(const Matrix<U>&, const Matrix<V>&, int, int, double, int);

}} // namespace isce3::core