Signal.h

// -*- C++ -*-
// -*- coding: utf-8 -*-
// 
// Author: Heresh Fattahi
// Copyright 2018-
//
 
#pragma once
 
#include "forward.h"
 
#include <cmath>
#include <memory>
#include <valarray>
 
#include <isce3/core/Constants.h>
#include <isce3/core/EMatrix.h>

template<class T> 
class isce3::signal::Signal {
    public: 
        Signal();

        Signal(int nthreads);
 
        ~Signal() {};

        void fftPlanForward(std::valarray<std::complex<T>> &input, 
                            std::valarray<std::complex<T>> &output,
                            int rank, int* n, int howmany,
                            int* inembed, int istride, int idist,
                            int* onembed, int ostride, int odist, int sign);

        void fftPlanForward(std::complex<T>* input,
                            std::complex<T>* output,
                            int rank, int* n, int howmany,
                            int* inembed, int istride, int idist,
                            int* onembed, int ostride, int odist, int sign);

        void fftPlanForward(std::valarray<T> &input,
                            std::valarray<std::complex<T>> &output,
                            int rank, int* n, int howmany,
                            int* inembed, int istride, int idist,
                            int* onembed, int ostride, int odist);

        void fftPlanForward(T* input,
                            std::complex<T>* output,
                            int rank, int* n, int howmany,
                            int* inembed, int istride, int idist,
                            int* onembed, int ostride, int odist);

        void fftPlanBackward(std::valarray<std::complex<T>> &input,
                            std::valarray<std::complex<T>> &output,
                            int rank, int* n, int howmany,
                            int* inembed, int istride, int idist,
                            int* onembed, int ostride, int odist, int sign);    

        void fftPlanBackward(std::complex<T>* input,
                            std::complex<T>* output,
                            int rank, int* n, int howmany,
                            int* inembed, int istride, int idist,
                            int* onembed, int ostride, int odist, int sign);

        void fftPlanBackward(std::valarray<std::complex<T>>& input,
                            std::valarray<T>& output,
                            int rank, int* n, int howmany,
                            int* inembed, int istride, int idist,
                            int* onembed, int ostride, int odist);

        void fftPlanBackward(std::complex<T>* input,
                            T* output,
                            int rank, int* n, int howmany,
                            int* inembed, int istride, int idist,
                            int* onembed, int ostride, int odist);

        void forward(std::valarray<std::complex<T>> &input,
                    std::valarray<std::complex<T>> &output);

        void forward(std::complex<T>* input,
                    std::complex<T>* output);

        void forward(std::valarray<T> &input,
                    std::valarray<std::complex<T>> &output);

        void forward(T* input,
                    std::complex<T>* output);
 
        

        void inverse(std::valarray<std::complex<T>> &input,
                    std::valarray<std::complex<T>> &output);

        void inverse(std::complex<T>* input,
                    std::complex<T>* output);

        void inverse(std::valarray<std::complex<T>>& input,
                    std::valarray<T>& output);

        void inverse(std::complex<T>* input,
                    T* output);

        void forwardRangeFFT(std::valarray<std::complex<T>>& signal, 
                    std::valarray<std::complex<T>>& spectrum,
                    int ncolumns, int nrows);

        void forwardRangeFFT(std::complex<T>* signal,
                    std::complex<T>* spectrum,
                    int ncolumns, int nrows);

        void forwardRangeFFT(std::valarray<T>& signal,
                    std::valarray<std::complex<T>>& spectrum,
                    int ncolumns, int nrows);

        void forwardRangeFFT(T* signal,
                    std::complex<T>* spectrum,
                    int ncolumns, int nrows);

        void forwardAzimuthFFT(std::valarray<std::complex<T>> &signal,
                                std::valarray<std::complex<T>> &spectrum,
                                int ncolumns, int nrows);

        void forwardAzimuthFFT(std::complex<T>* signal,
                                std::complex<T>* spectrum,
                                int ncolumns, int nrows);

        void forwardAzimuthFFT(std::valarray<T> &signal,
                                std::valarray<std::complex<T>> &spectrum,
                                int ncolumns, int nrows);

        void forwardAzimuthFFT(T* signal,
                                std::complex<T>* spectrum,
                                int ncolumns, int nrows);

        void forward2DFFT(std::valarray<std::complex<T>> &signal,
                                std::valarray<std::complex<T>> &spectrum,
                                int ncolumns, int nrows);

        void forward2DFFT(std::valarray<std::complex<T>> &signal,
                                std::valarray<std::complex<T>> &spectrum,
                                int incolumns, int inrows,
                                int oncolumns, int onrows);
        
        void forward2DFFT(std::complex<T>* signal,
                                std::complex<T>* spectrum,
                                int ncolumns, int nrows);

        void forward2DFFT(std::complex<T>* signal,
                                std::complex<T>* spectrum,
                                int incolumns, int inrows,
                                int oncolumns, int onrows);

        void forward2DFFT(std::valarray<T>& signal,
                            std::valarray<std::complex<T>>& spectrum,
                            int ncolumns, int nrows);

        void forward2DFFT(std::valarray<T>& signal,
                            std::valarray<std::complex<T>>& spectrum,
                            int incolumns, int inrows,
                            int oncolumns, int onrows);

        void forward2DFFT(T* signal,
                            std::complex<T>* spectrum,
                            int ncolumns, int nrows);

        void forward2DFFT(T* signal,
                            std::complex<T>* spectrum,
                            int incolumns, int inrows,
                            int oncolumns, int onrows);

        void inverseRangeFFT(std::valarray<std::complex<T>> &spectrum, 
                            std::valarray<std::complex<T>> &signal,
                            int ncolumns, int nrows);

        void inverseRangeFFT(std::complex<T>* spectrum,
                            std::complex<T>* signal,
                            int ncolumns, int nrows);

        void inverseRangeFFT(std::valarray<std::complex<T>> &spectrum,
                            std::valarray<T> &signal,
                            int ncolumns, int nrows);

        void inverseRangeFFT(std::complex<T>* spectrum,
                            T* signal,
                            int ncolumns, int nrows);

        void inverseAzimuthFFT(std::valarray<std::complex<T>> &spectrum,
                                std::valarray<std::complex<T>> &signal,
                                int ncolumns, int nrows);

        void inverseAzimuthFFT(std::complex<T>* spectrum,
                                std::complex<T>* signal,
                                int ncolumns, int nrows);
        void inverseAzimuthFFT(std::valarray<std::complex<T>> &spectrum,
                                std::valarray<T> &signal,
                                int ncolumns, int nrows);

        void inverseAzimuthFFT(std::complex<T>* spectrum,
                                T* signal,
                                int ncolumns, int nrows);

        void inverse2DFFT(std::valarray<std::complex<T>> &spectrum,
                            std::valarray<std::complex<T>> &signal,
                            int ncolumns, int nrows);

        void inverse2DFFT(std::complex<T>* spectrum,
                            std::complex<T>* signal,
                            int ncolumns, int nrows);
        
        void inverse2DFFT(std::valarray<std::complex<T>> &spectrum,
                            std::valarray<T> &signal,
                            int ncolumns, int nrows);

        void inverse2DFFT(std::complex<T>* spectrum,
                            T* signal,
                            int ncolumns, int nrows);
 

        void upsample(std::valarray<std::complex<T>> &signal,
                    std::valarray<std::complex<T>> &signalOversampled,
                    int rows, int fft_size, int oversampleFactor);

        void upsample(std::valarray<std::complex<T>> &signal,
                    std::valarray<std::complex<T>> &signalOversampled,
                    int rows, int fft_size, int oversampleFactor,
                    std::valarray<std::complex<T>> shiftImpact);

        void upsample(
                isce3::core::EArray2D<std::complex<T>>& signal,
                isce3::core::EArray2D<std::complex<T>>& signalUpsampled,
                const isce3::core::EArray2D<std::complex<T>>& shiftImpact = {});

        void upsample2D(std::valarray<std::complex<T>> &signal,
                        std::valarray<std::complex<T>> &signalOversampled,
                        int oversampleFactor);

        void upsample2D(std::valarray<std::complex<T>> &signal,
                        std::valarray<std::complex<T>> &signalOversampled,
                        int oversampleFactor,
                        std::valarray<std::complex<T>> &shiftImpact);
 

        void upsample2D(std::complex<T> *signal,
                        std::complex<T> *signalOversampled,
                        int oversampleFactor);

        void upsample2D(std::complex<T> *signal,
                        std::complex<T> *signalOversampled,
                        int oversampleFactor,
                        std::complex<T> *shiftImpact);
 
 
 

        inline void nextPowerOfTwo(size_t N, size_t& fftLength);
 

        inline void _fwd_configure(int rank, int* n, int howmany,
                               int* inembed, int istride, int idist,
                               int* onembed, int ostride, int odist);

        inline void _rev_configure(int rank, int* n, int howmany,
                               int* inembed, int istride, int idist,
                               int* onembed, int ostride, int odist);
 

        inline void _fwd_configureRangeFFT(int ncolumns, int nrows);

        inline void _fwd_configureAzimuthFFT(int ncolumns, int nrows);

        inline void _fwd_configure2DFFT(int incolumns, int inrows, int oncolumns, int onrows);

        inline void _rev_configureRangeFFT(int ncolumns, int nrows);

        inline void _rev_configureAzimuthFFT(int ncolumns, int nrows);

        inline void _rev_configure2DFFT(int ncolumns, int nrows);
 
 
    private:
        int _fwd_rank;
        int* _fwd_n;
        int _fwd_howmany;
        int* _fwd_inembed;
        int _fwd_istride;
        int _fwd_idist;
        int* _fwd_onembed;
        int _fwd_ostride;
        int _fwd_odist;
 
        int _rev_rank;
        int* _rev_n;
        int _rev_howmany;
        int* _rev_inembed;
        int _rev_istride;
        int _rev_idist;
        int* _rev_onembed;
        int _rev_ostride;
        int _rev_odist;
 
        struct impl;
        std::unique_ptr<impl, void(*)(impl*)> pimpl;
};
 
#define ISCE_SIGNAL_SIGNAL_ICC
#include "Signal.icc"
#undef ISCE_SIGNAL_SIGNAL_ICC