Covariance.h

// -*- C++ -*-
// -*- coding: utf-8 -*-
//
// Author: Heresh Fattahi
// Copyright 2019-
//

#pragma once

#include "forward.h"

#include <map>

// isce3::core
#include <isce3/core/Ellipsoid.h>
#include <isce3/core/LUT2d.h>
#include <isce3/core/Orbit.h>

// isce3::product
#include <isce3/product/RadarGridParameters.h>

// isce3::io
#include <isce3/io/Raster.h>

// isce3::geometry
#include <isce3/geometry/geometry.h>

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

    void covariance(std::map<std::string, isce3::io::Raster> & slc,
                    std::map<std::pair<std::string, std::string>,
                             isce3::io::Raster> & cov,
                    size_t rangeLooks=1, size_t azimuthLooks=1);

    void faradayRotation(std::map<std::string, isce3::io::Raster> & slc,
                         isce3::io::Raster & faradayAngleRaster,
                         size_t rangeLooks, size_t azimuthLooks);

    void orientationAngle(isce3::io::Raster & azimuthSlopeRaster,
                          isce3::io::Raster & rangeSlopeRaster,
                          isce3::io::Raster & lookAngleRaster,
                          isce3::io::Raster & tauRaster);

    void geocodeCovariance(isce3::io::Raster & rdrCov, isce3::io::Raster & geoCov,
                           isce3::io::Raster & demRaster);

    void geocodeCovariance(isce3::io::Raster & rdrCov, isce3::io::Raster & geoCov,
                           isce3::io::Raster & demRaster,
                           isce3::io::Raster & rtc);

    void geocodeCovariance(isce3::io::Raster & rdrCov, isce3::io::Raster & geoCov,
                           isce3::io::Raster & demRaster, isce3::io::Raster & rtc,
                           isce3::io::Raster & orientationAngle);

    void geoGrid(double geoGridStartX, double geoGridStartY,
                 double geoGridSpacingX, double geoGridSpacingY,
                 double geoGridEndX, double geoGridEndY, int epsgcode);

    void geoGrid(double geoGridStartX, double geoGridStartY,
                 double geoGridSpacingX, double geoGridSpacingY, int width,
                 int length, int epsgcode);

    void radarGrid(isce3::core::LUT2d<double> doppler,
                   isce3::core::DateTime refEpoch, double azimuthStartTime,
                   double azimuthTimeInterval, int radarGridLength,
                   double startingRange, double rangeSpacing,
                   isce3::core::LookSide side,
                   double wavelength, int radarGridWidth);

    void prf(double p) { _prf = p; }

    void doppler(const isce3::core::LUT2d<double> & dop) { _doppler = dop; }

    void rangeSamplingFrequency(double rngSamplingFreq);

    void rangeBandwidth(double rngBandwidth) { _rangeBandwidth = rngBandwidth; }

    void rangePixelSpacing(double rngPixelSpacing) { _rangePixelSpacing = rngPixelSpacing; }

    void wavelength(double wvl) { _wavelength = wvl; }

    void interpolator(isce3::core::dataInterpMethod method);

    void orbit(const isce3::core::Orbit & orbit) { _orbit = orbit; }

    void ellipsoid(const isce3::core::Ellipsoid & ellipsoid) { _ellipsoid = ellipsoid; }

    void projection(isce3::core::ProjectionBase * proj) { _proj = proj; }

    void thresholdGeo2rdr(double threshold) { _threshold = threshold; }

    void numiterGeo2rdr(int numiter) { _numiter = numiter; }

    void linesPerBlock(size_t linesPerBlock) { _linesPerBlock = linesPerBlock; }

    void demBlockMargin(double demBlockMargin) { _demBlockMargin = demBlockMargin; }

    void radarBlockMargin(int radarBlockMargin) { _radarBlockMargin = radarBlockMargin; }

    void interpolator(isce3::core::Interpolator<T> * interp) { _interp = interp; }

private:
    void _correctRTC(std::valarray<std::complex<float>> & rdrDataBlock,
                     std::valarray<float> & rtcDataBlock);

    void _correctRTC(std::valarray<std::complex<double>> & rdrDataBlock,
                     std::valarray<float> & rtcDataBlock);

    void _computeRangeAzimuthBoundingBox(
            int lineStart, int blockLength, int blockWidth, int margin,
            isce3::geometry::DEMInterpolator & demInterp, int & azimuthFirstLine,
            int & azimuthLastLine, int & rangeFirstPixel, int & rangeLastPixel);

    void _loadDEM(isce3::io::Raster demRaster,
                  isce3::geometry::DEMInterpolator & demInterp,
                  isce3::core::ProjectionBase * _proj, int lineStart,
                  int blockLength, int blockWidth, double demMargin);

    void _geo2rdr(double x, double y, double & azimuthTime, double & slantRange,
                  isce3::geometry::DEMInterpolator & demInterp);

    void _interpolate(std::valarray<T> & rdrDataBlock,
                      std::valarray<T> & geoDataBlock,
                      std::valarray<double> & radarX,
                      std::valarray<double> & radarY, size_t radarBlockWidth,
                      size_t radarBlockLength, size_t width, size_t length);

    void _faradayRotationAngle(std::valarray<T> & Shh, std::valarray<T> & Shv,
                               std::valarray<T> & Svh, std::valarray<T> & Svv,
                               std::valarray<float> & faradayRotation,
                               size_t width, size_t length, size_t rngLooks,
                               size_t azLooks);

    void _correctFaradayRotation(isce3::core::LUT2d<double> & faradayAngle,
                                 std::valarray<std::complex<float>> & Shh,
                                 std::valarray<std::complex<float>> & Shv,
                                 std::valarray<std::complex<float>> & Svh,
                                 std::valarray<std::complex<float>> & Svv,
                                 size_t length, size_t width, size_t lineStart);

    void _orientationAngle(std::valarray<float> & azimuthSlope,
                           std::valarray<float> & rangeSlope,
                           std::valarray<float> & lookAngle,
                           std::valarray<float> & tau);

    void _correctOrientation(std::valarray<float> & tau,
                             std::valarray<std::complex<float>> & C11,
                             std::valarray<std::complex<float>> & C12,
                             std::valarray<std::complex<float>> & C13,
                             std::valarray<std::complex<float>> & C21,
                             std::valarray<std::complex<float>> & C22,
                             std::valarray<std::complex<float>> & C23,
                             std::valarray<std::complex<float>> & C31,
                             std::valarray<std::complex<float>> & C32,
                             std::valarray<std::complex<float>> & C33);

    // pulse repetition frequency
    double _prf;

    // range samping frequency
    double _rangeSamplingFrequency;

    // range signal bandwidth
    double _rangeBandwidth;

    // range pixel spacing
    double _rangePixelSpacing;

    // radar wavelength
    double _wavelength;

    // The following needed for geocoding

    // isce3::core objects
    isce3::core::Orbit _orbit;
    isce3::core::Ellipsoid _ellipsoid;

    // Optimization options
    double _threshold;
    int _numiter;
    size_t _linesPerBlock = 2000;

    // radar grids parameters
    isce3::core::LUT2d<double> _doppler;
    isce3::product::RadarGridParameters _radarGrid;

    // start X position for the output geocoded grid
    double _geoGridStartX;

    // start Y position for the output geocoded grid
    double _geoGridStartY;

    // X spacing for the output geocoded grid
    double _geoGridSpacingX;

    // Y spacing for the output geocoded grid
    double _geoGridSpacingY;

    // number of pixels in east-west direction (X direction)
    size_t _geoGridWidth;

    // number of lines in north-south direction (Y direction)
    size_t _geoGridLength;

    // geoTransform array (gdal style)
    double * _geoTrans;

    // epsg code for the output geocoded grid
    int _epsgOut;

    // projection object
    isce3::core::ProjectionBase * _proj = nullptr;

    // margin around a computed bounding box for DEM (in degrees)
    double _demBlockMargin;

    // margin around the computed bounding box for radar dara (integer number of
    // lines/pixels)
    int _radarBlockMargin;

    // interpolator
    isce3::core::Interpolator<T> * _interp = nullptr;

    // RTC correction flag for geocoded covariance
    bool _correctRtcFlag = true;

    // Polarimetric orientation correction flag for geocoded covariance
    bool _correctOrientationFlag = true;

    // dualPol or Quadpol flags
    bool _singlePol = false;
    bool _dualPol = false;
    bool _quadPol = false;

    // coPol and crossPol names (used only for dual-pol)
    std::string _coPol;
    std::string _crossPol;
};

// Get inline implementations for Geocode
#define ISCE_SIGNAL_COVARIANCE_ICC
#include "Covariance.icc"
#undef ISCE_SIGNAL_COVARIANCE_ICC