GeocodePolygon.h

#pragma once
 
// pyre
#include <pyre/journal.h>
 
// isce3::core
#include <isce3/core/Ellipsoid.h>
#include <isce3/core/LUT2d.h>
#include <isce3/core/Orbit.h>
 
// isce3::io
#include <isce3/io/Raster.h>
 
// isce3::product
#include <isce3/product/RadarGridParameters.h>
 
// isce3::geometry
#include <isce3/geometry/RTC.h>
 
 
namespace isce3 { namespace geocode {
 
template<class T>
class GeocodePolygon {
public:

    GeocodePolygon(const std::vector<double>& x_vect,
                   const std::vector<double>& y_vect,
                   const isce3::product::RadarGridParameters& radar_grid,
                   const isce3::core::Orbit& orbit,
                   const isce3::core::Ellipsoid& ellipsoid,
                   const isce3::core::LUT2d<double>& input_dop,
                   isce3::io::Raster& dem_raster, double threshold = 1e-8,
                   int num_iter = 100, double delta_range = 1e-8);

    void getPolygonMean(
            const isce3::product::RadarGridParameters& radar_grid,
            const isce3::core::LUT2d<double>& input_dop,
            isce3::io::Raster& input_raster,
            isce3::io::Raster& output_raster,
            isce3::io::Raster& dem_raster,
            bool flag_apply_rtc = false,
            isce3::geometry::rtcInputTerrainRadiometry input_terrain_radiometry =
                    isce3::geometry::rtcInputTerrainRadiometry::BETA_NAUGHT,
            isce3::geometry::rtcOutputTerrainRadiometry
                    output_terrain_radiometry = isce3::geometry::
                            rtcOutputTerrainRadiometry::GAMMA_NAUGHT,
            int exponent = 0,
            double geogrid_upsampling =
                    std::numeric_limits<double>::quiet_NaN(),
            float rtc_min_value_db = std::numeric_limits<float>::quiet_NaN(),
            double abs_cal_factor = 1, float radar_grid_nlooks = 1,
            isce3::io::Raster* output_off_diag_terms = nullptr,
            isce3::io::Raster* output_radargrid_data = nullptr,
            isce3::io::Raster* output_rtc = nullptr,
            isce3::io::Raster* output_weights = nullptr,
            isce3::core::dataInterpMethod interp_method =
                    isce3::core::dataInterpMethod::BIQUINTIC_METHOD);
 
    // Radar grid X offset
    int xoff() const { return _xoff; }
 
    // Radar grid Y offset
    int yoff() const { return _yoff; }
 
    // Cropped radar grid X size
    int xsize() const { return _xsize; }
 
    // Cropped radar grid Y size
    int ysize() const { return _ysize; }
 
    // Output number of looks
    float out_nlooks() const { return _out_nlooks; }
 
private:
 
    std::vector<double> _az_time_vect, _slant_range_vect;
    int _xoff;
    int _yoff;
    int _xsize;
    int _ysize;
 
    float _out_nlooks;
 
    double _threshold;
    int _num_iter;
    double _delta_range;
        
    isce3::core::Orbit _orbit;
 
    template<class T_out>
    void _getPolygonMean(
            isce3::core::Matrix<float>& rtc_area,
            const isce3::product::RadarGridParameters& radar_grid,
            isce3::io::Raster& input_raster,
            isce3::io::Raster& output_raster,
            bool flag_apply_rtc = false,
            float rtc_min_value = 0, 
            double abs_cal_factor = 1, float radar_grid_nlooks = 1,
            isce3::io::Raster* output_off_diag_terms = nullptr,
            isce3::io::Raster* output_radargrid_data = nullptr,
            isce3::io::Raster* output_weights = nullptr);
 
    void _ValidatePolygon(
            const isce3::product::RadarGridParameters& radar_grid);
 
};
 
}} // namespace isce3::geocode