gpuFilter.h

//
// Author: Liang Yu
// Copyright 2019
//

#pragma once

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

#include <complex>
#include <valarray>
#include <thrust/complex.h>

#include "gpuSignal.h"

// Definition of base class
template<class T>
class isce3::cuda::signal::gpuFilter {
    public:
        gpuFilter() {};
        ~gpuFilter();

        void filter(std::valarray<std::complex<T>> &signal,
                std::valarray<std::complex<T>> &spectrum);

        void filter(gpuSignal<T> &signal);

        void filter(thrust::complex<T> *data);

        void writeFilter(size_t ncols, size_t nrows);

    protected:

        thrust::complex<T> *_d_filter;               // device unified memory pointer
        bool _filter_set = false;
        gpuSignal<T> _signal;
};

// Azimuth filter class derived from base class
template <class T>
class isce3::cuda::signal::gpuAzimuthFilter : public gpuFilter<T> {
    public:
        gpuAzimuthFilter();
        ~gpuAzimuthFilter() {};

        void initiateAzimuthFilter(std::valarray<std::complex<T>> &signal,
                std::valarray<std::complex<T>> &spectrum,
                size_t ncols,
                size_t nrows);

        void constructAzimuthCommonbandFilter(const isce3::core::LUT1d<double> & refDoppler,
                const isce3::core::LUT1d<double> & secDoppler,
                double bandwidth,
                double prf,
                double beta,
                //std::valarray<std::complex<T>> &signal,
                size_t ncols,
                size_t nrows);
};

// Range filter class derived from base class
template <class T>
class isce3::cuda::signal::gpuRangeFilter : public gpuFilter<T> {
    public:
        gpuRangeFilter();
        ~gpuRangeFilter();

        // same name wrappers for filter init and construction functions with HostToDevice cp
        void initiateRangeFilter(std::valarray<std::complex<T>> &signal,
                std::valarray<std::complex<T>> &spectrum,
                size_t ncols,
                size_t nrows);

        void constructRangeBandpassFilter(double rangeSamplingFrequency,
                std::valarray<double> subBandCenterFrequencies,
                std::valarray<double> subBandBandwidths,
                std::valarray<std::complex<T>> &signal,
                std::valarray<std::complex<T>> &spectrum,
                size_t ncols,
                size_t nrows,
                std::string filterType);

        void constructRangeBandpassFilter(double rangeSamplingFrequency,
                std::valarray<double> subBandCenterFrequencies,
                std::valarray<double> subBandBandwidths,
                size_t ncols,
                size_t nrows,
                std::string filterType);

        void constructRangeBandpassBoxcar(std::valarray<double> subBandCenterFrequencies,
                std::valarray<double> subBandBandwidths,
                double dt,
                int nfft,
                std::valarray<std::complex<T>> &_filter1D);

        void constructRangeBandpassCosine(std::valarray<double> subBandCenterFrequencies,
                std::valarray<double> subBandBandwidths,
                double dt,
                std::valarray<double>& frequency,
                double beta,
                std::valarray<std::complex<T>>& _filter1D);

        void filterCommonRangeBand(T *d_refSlc, T *d_secSlc, T *range);

        size_t rangeFrequencyShiftMaxIdx(thrust::complex<T> *spectrum,
                int n_rows,
                int n_cols);

        void getPeakIndex(T *data, int data_lenth, size_t &peakIndex);

    private:
        double _wavelength;
        double _rangePixelSpacing;
        double _freqShift;
        double _rangeBandWidth;
        double _rangeSamplingFrequency;
        double _rangeBandwidth;
        T *_d_spectrumSum;
        bool _spectrumSum_set = false;
};

template<class T>
__global__ void phaseShift_g(thrust::complex<T> *slc, T *range, double pxlSpace, T conj, double wavelength, T wave_div, int n_elements);

template<class T>
__global__ void filter_g(thrust::complex<T> *signal, thrust::complex<T> *filter, int n_elements);

template<class T>
__global__ void sumSpectrum_g(thrust::complex<T> *spectrum, T *spectrum_sum, int n_rows, int n_cols);