Crossmul.h

// -*- C++ -*-
// -*- coding: utf-8 -*-
//
// Author: Heresh Fattahi, Bryan Riel
// Copyright 2018-
//

#pragma once

#include "forward.h"

#include <complex>
#include <isce3/core/LUT1d.h>
#include <isce3/io/forward.h>

class isce3::signal::Crossmul {
    public:
        // Constructor from product
        Crossmul() {};

        ~Crossmul() {};
        
        /*
        void Crossmul(const isce3::product::Product& referenceSLC,
                    const isce3::product::Product& secondarySLC,
                    const isce3::product::Product& outputInterferogram);
        */


        void crossmul(isce3::io::Raster& referenceSLC,
                    isce3::io::Raster& secondarySLC,
                    isce3::io::Raster& rngOffset,
                    isce3::io::Raster& interferogram,
                    isce3::io::Raster& coherence);

        void crossmul(isce3::io::Raster& referenceSLC, 
                    isce3::io::Raster& secondarySLC,
                    isce3::io::Raster& interferogram,
                    isce3::io::Raster& coherence);

        void crossmul(isce3::io::Raster& referenceSLC,
                    isce3::io::Raster& secondarySLC,
                    isce3::io::Raster& interferogram);

        void lookdownShiftImpact(size_t oversample, size_t fft_size,
                                size_t blockRows,
                                std::valarray<std::complex<float>> &shiftImpact);

        void rangeCommonBandFilter(std::valarray<std::complex<float>> &refSlc,
                        std::valarray<std::complex<float>> &secSlc,
                        std::valarray<std::complex<float>> geometryIfgram,
                        std::valarray<std::complex<float>> geometryIfgramConj,
                        std::valarray<std::complex<float>> &refSpectrum,
                        std::valarray<std::complex<float>> &secSpectrum,
                        std::valarray<double> &rangeFrequencies,
                        isce3::signal::Filter<float> &rngFilter,
                        size_t blockRows,
                        size_t ncols);
        

        inline void doppler(isce3::core::LUT1d<double>, 
                            isce3::core::LUT1d<double>);

        inline void prf(double);

        inline void rangeSamplingFrequency(double);

        inline void rangeBandwidth(double);

        inline void rangePixelSpacing(double);

        inline void wavelength(double);


        inline void commonAzimuthBandwidth(double);

        inline void beta(double);


        inline void rangeLooks(int);

        inline void azimuthLooks(int);

        inline void doCommonAzimuthbandFiltering(bool);

        inline void doCommonRangebandFiltering(bool);

        inline void rangeFrequencyShift(std::valarray<std::complex<float>> &refAvgSpectrum,
                                        std::valarray<std::complex<float>> &secAvgSpectrum,
                                        std::valarray<double> &rangeFrequencies,
                                        size_t blockRowsData,
                                        size_t fft_size,
                                        double &frequencyShift);

        inline void getPeakIndex(std::valarray<float> data, 
                                size_t &peakIndex);

    private:
        //Doppler LUT for the refernce SLC
        isce3::core::LUT1d<double> _refDoppler;

        //Doppler LUT for the secondary SLC
        isce3::core::LUT1d<double> _secDoppler;

        //pulse repetition frequency
        double _prf;

        // range samping frequency
        double _rangeSamplingFrequency;

        // range signal bandwidth
        double _rangeBandwidth;
        
        // range pixel spacing
        double _rangePixelSpacing;

        // radar wavelength
        double _wavelength;

        //azimuth common bandwidth
        double _commonAzimuthBandwidth;

        // beta parameter for constructing common azimuth band filter
        double _beta;

        // number of range looks
        int _rangeLooks = 1;

        // number of azimuth looks
        int _azimuthLooks = 1;

        bool _doMultiLook = false;

        // Flag for common azimuth band filtering
        bool _doCommonAzimuthbandFilter = false;

        // Flag for common range band filtering
        bool _doCommonRangebandFilter = false;

        // Flag for computing coherence
        bool _computeCoherence = true;

        // number of lines per block
        size_t blockRows = 8192;

        // upsampling factor
        size_t oversample = 1;

        
};

// Get inline implementations for Crossmul
#define ISCE_SIGNAL_CROSSMUL_ICC
#include "Crossmul.icc"
#undef ISCE_SIGNAL_CROSSMUL_ICC