gpuLUT2d.h

#pragma once

#include "forward.h"
#include <isce3/core/forward.h>
#include <isce3/cuda/core/forward.h>

#include <cmath>

#include <isce3/core/Common.h>
#include <isce3/core/Constants.h>

namespace isce3 { namespace cuda { namespace core {

template<typename T>
class gpuLUT2d {
public:
    gpuLUT2d(const isce3::core::LUT2d<T>&);

    gpuLUT2d(const gpuLUT2d<T>&);

    CUDA_HOSTDEV gpuLUT2d(gpuLUT2d<T>&);

    CUDA_HOSTDEV gpuLUT2d& operator=(gpuLUT2d<T>&);

    ~gpuLUT2d();

    CUDA_HOSTDEV double xStart() const { return _xstart; }

    CUDA_HOSTDEV double yStart() const { return _ystart; }

    CUDA_HOSTDEV double xSpacing() const { return _dx; }

    CUDA_HOSTDEV double ySpacing() const { return _dy; }

    CUDA_HOSTDEV size_t length() const { return _length; }

    CUDA_HOSTDEV size_t width() const { return _width; }

    CUDA_HOSTDEV T refValue() const { return _refValue; }

    CUDA_HOSTDEV bool haveData() const { return _haveData; }

    CUDA_HOSTDEV bool boundsError() const { return _boundsError; }

    CUDA_HOSTDEV
    isce3::core::dataInterpMethod interpMethod() const { return _interpMethod; }

    CUDA_HOSTDEV gpuInterpolator<T>** interp() const { return _interp; }

    CUDA_HOSTDEV T* data() { return _data; }

    CUDA_HOSTDEV const T* data() const { return _data; }

    CUDA_HOSTDEV void data(T* v) { _data = v; }

    CUDA_DEV T eval(double y, double x) const;

    T eval_h(double y, double x);

private:
    // Flags
    bool _haveData;
    bool _boundsError;
    T _refValue;
    // Coordinates
    double _xstart, _ystart, _dx, _dy;
    // LUT data
    size_t _length, _width;
    T* _data;
    // Interpolator pointer
    isce3::core::dataInterpMethod _interpMethod;
    gpuInterpolator<T>** _interp;
    // Do I own data?
    bool _owner;

    // Interpolation pointer handlers

    void _initInterp();

    void _finalizeInterp();
};

}}} // namespace isce3::cuda::core