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 xEnd() const { return xStart() + (width() - 1) * xSpacing(); }

    CUDA_HOSTDEV double yEnd() const { return yStart() + (length() - 1) * ySpacing(); }

    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);

    CUDA_HOSTDEV bool contains(double y, double x) const
    {
        // Treat default-constructed LUT as having infinite extent.
        if (not _haveData) {
            return true;
        }
 
        return (x >= xStart()) and (x <= xEnd()) and
               (y >= yStart()) and (y <= yEnd());
    }
 
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