RTC.h

#pragma once
 
#include "forward.h"
#include <isce3/core/forward.h>
#include <isce3/io/forward.h>
#include <isce3/product/forward.h>
 
#include <limits>
 
#include <pyre/journal.h>
 
#include <isce3/core/Constants.h>
#include <isce3/core/blockProcessing.h>
#include <isce3/core/LUT2d.h>
#include <isce3/error/ErrorCode.h>
 
namespace isce3 { namespace geometry {

enum rtcInputTerrainRadiometry {
    BETA_NAUGHT = 0,
    SIGMA_NAUGHT_ELLIPSOID = 1,
};

enum rtcOutputTerrainRadiometry {
    SIGMA_NAUGHT = 0,
    GAMMA_NAUGHT = 1,
};

enum rtcAreaMode { AREA = 0, AREA_FACTOR = 1 };

enum rtcAlgorithm { RTC_BILINEAR_DISTRIBUTION = 0, RTC_AREA_PROJECTION = 1 };

enum rtcAreaBetaMode {
        AUTO = 0,  
        PIXEL_AREA = 1,  
        PROJECTION_ANGLE = 2 
};

void applyRtc(const isce3::product::RadarGridParameters& radarGrid,
        const isce3::core::Orbit& orbit, const isce3::core::LUT2d<double>& dop,
        isce3::io::Raster& input_raster, isce3::io::Raster& dem_raster,
        isce3::io::Raster& output_raster,
        rtcInputTerrainRadiometry input_terrain_radiometry =
                rtcInputTerrainRadiometry::BETA_NAUGHT,
        rtcOutputTerrainRadiometry output_terrain_radiometry =
                rtcOutputTerrainRadiometry::GAMMA_NAUGHT,
        int exponent = 0, rtcAreaMode rtc_area_mode = rtcAreaMode::AREA_FACTOR,
        rtcAlgorithm rtc_algorithm = rtcAlgorithm::RTC_AREA_PROJECTION,
        rtcAreaBetaMode rtc_area_beta_mode = rtcAreaBetaMode::AUTO,
        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 clip_min = std::numeric_limits<float>::quiet_NaN(),
        float clip_max = std::numeric_limits<float>::quiet_NaN(),
        isce3::io::Raster* out_sigma = nullptr,
        const isce3::core::LUT2d<double>& az_time_correction = {},
        const isce3::core::LUT2d<double>& slant_range_correction = {},
        isce3::io::Raster* input_rtc = nullptr,
        isce3::io::Raster* output_rtc = nullptr,
        isce3::core::MemoryModeBlocksY rtc_memory_mode = 
                isce3::core::MemoryModeBlocksY::AutoBlocksY);
 

void computeRtc(const isce3::product::RadarGridParameters& radarGrid,
        const isce3::core::Orbit& orbit, const isce3::core::LUT2d<double>& dop,
        isce3::io::Raster& dem, isce3::io::Raster& output_raster,
        rtcInputTerrainRadiometry inputTerrainRadiometry =
                rtcInputTerrainRadiometry::BETA_NAUGHT,
        rtcOutputTerrainRadiometry outputTerrainRadiometry =
                rtcOutputTerrainRadiometry::GAMMA_NAUGHT,
        rtcAreaMode rtc_area_mode = rtcAreaMode::AREA_FACTOR,
        rtcAlgorithm rtc_algorithm = rtcAlgorithm::RTC_AREA_PROJECTION,
        rtcAreaBetaMode rtc_area_beta_mode = rtcAreaBetaMode::AUTO,
        double geogrid_upsampling = std::numeric_limits<double>::quiet_NaN(),
        float rtc_min_value_db = std::numeric_limits<float>::quiet_NaN(),
        isce3::io::Raster* out_sigma = nullptr,
        const isce3::core::LUT2d<double>& az_time_correction = {},
        const isce3::core::LUT2d<double>& slant_range_correction = {},
        isce3::core::MemoryModeBlocksY rtc_memory_mode = 
                isce3::core::MemoryModeBlocksY::AutoBlocksY,
        isce3::core::dataInterpMethod interp_method =
                isce3::core::dataInterpMethod::BIQUINTIC_METHOD,
        double threshold = 1e-8, int num_iter = 100, double delta_range = 1e-8,
        const long long min_block_size = isce3::core::DEFAULT_MIN_BLOCK_SIZE,
        const long long max_block_size = isce3::core::DEFAULT_MAX_BLOCK_SIZE);

void computeRtc(isce3::io::Raster& dem_raster, isce3::io::Raster& output_raster,
        const isce3::product::RadarGridParameters& radarGrid,
        const isce3::core::Orbit& orbit, const isce3::core::LUT2d<double>& dop,
        const double y0, const double dy, const double x0, const double dx,
        const int geogrid_length, const int geogrid_width, const int epsg,
        rtcInputTerrainRadiometry inputTerrainRadiometry =
                rtcInputTerrainRadiometry::BETA_NAUGHT,
        rtcOutputTerrainRadiometry outputTerrainRadiometry =
                rtcOutputTerrainRadiometry::GAMMA_NAUGHT,
        rtcAreaMode rtc_area_mode = rtcAreaMode::AREA_FACTOR,
        rtcAlgorithm rtc_algorithm = rtcAlgorithm::RTC_AREA_PROJECTION,
        rtcAreaBetaMode rtc_area_beta_mode = rtcAreaBetaMode::AUTO,
        double geogrid_upsampling = std::numeric_limits<double>::quiet_NaN(),
        float rtc_min_value_db = std::numeric_limits<float>::quiet_NaN(),
        isce3::io::Raster* out_geo_rdr = nullptr,
        isce3::io::Raster* out_geo_grid = nullptr,
        isce3::io::Raster* out_sigma = nullptr,
        const isce3::core::LUT2d<double>& az_time_correction = {},
        const isce3::core::LUT2d<double>& slant_range_correction = {},
        isce3::core::MemoryModeBlocksY rtc_memory_mode = 
                isce3::core::MemoryModeBlocksY::AutoBlocksY,
        isce3::core::dataInterpMethod interp_method =
                isce3::core::dataInterpMethod::BIQUINTIC_METHOD,
        double threshold = 1e-8, int num_iter = 100, double delta_range = 1e-8,
        const long long min_block_size = isce3::core::DEFAULT_MIN_BLOCK_SIZE,
        const long long max_block_size = isce3::core::DEFAULT_MAX_BLOCK_SIZE);

void computeRtcBilinearDistribution(isce3::io::Raster& dem_raster,
        isce3::io::Raster& output_raster,
        const isce3::product::RadarGridParameters& radarGrid,
        const isce3::core::Orbit& orbit, const isce3::core::LUT2d<double>& dop,
        const isce3::product::GeoGridParameters& geogrid,
        rtcInputTerrainRadiometry input_terrain_radiometry =
                rtcInputTerrainRadiometry::BETA_NAUGHT,
        rtcOutputTerrainRadiometry output_terrain_radiometry =
                rtcOutputTerrainRadiometry::GAMMA_NAUGHT,
        rtcAreaMode rtc_area_mode = rtcAreaMode::AREA_FACTOR,
        double geogrid_upsampling = std::numeric_limits<double>::quiet_NaN(),
        float rtc_min_value_db = std::numeric_limits<float>::quiet_NaN(),
        isce3::io::Raster* out_sigma = nullptr,
        double threshold = 1e-8, int num_iter = 100, double delta_range = 1e-8,
        const isce3::core::LUT2d<double>& az_time_correction = {},
        const isce3::core::LUT2d<double>& slant_range_correction = {});

void computeRtcAreaProj(isce3::io::Raster& dem,
        isce3::io::Raster& output_raster,
        const isce3::product::RadarGridParameters& radarGrid,
        const isce3::core::Orbit& orbit, const isce3::core::LUT2d<double>& dop,
        const isce3::product::GeoGridParameters& geogrid,
        rtcInputTerrainRadiometry input_terrain_radiometry =
                rtcInputTerrainRadiometry::BETA_NAUGHT,
        rtcOutputTerrainRadiometry output_terrain_radiometry =
                rtcOutputTerrainRadiometry::GAMMA_NAUGHT,
        rtcAreaMode rtc_area_mode = rtcAreaMode::AREA_FACTOR,
        rtcAreaBetaMode rtc_area_beta_mode = rtcAreaBetaMode::AUTO,
        double geogrid_upsampling = std::numeric_limits<double>::quiet_NaN(),
        float rtc_min_value_db = std::numeric_limits<float>::quiet_NaN(),
        isce3::io::Raster* out_geo_rdr = nullptr,
        isce3::io::Raster* out_geo_grid = nullptr,
        isce3::io::Raster* out_sigma = nullptr,
        const isce3::core::LUT2d<double>& az_time_correction = {},
        const isce3::core::LUT2d<double>& slant_range_correction = {},
        isce3::core::MemoryModeBlocksY rtc_memory_mode = 
                isce3::core::MemoryModeBlocksY::AutoBlocksY,
        isce3::core::dataInterpMethod interp_method =
                isce3::core::dataInterpMethod::BIQUINTIC_METHOD,
        double threshold = 1e-8, int num_iter = 100, double delta_range = 1e-8,
        const long long min_block_size = isce3::core::DEFAULT_MIN_BLOCK_SIZE,
        const long long max_block_size = isce3::core::DEFAULT_MAX_BLOCK_SIZE);
 
void areaProjIntegrateSegment(double y1, double y2, double x1, double x2,
        int length, int width, isce3::core::Matrix<double>& w_arr,
        double& w_total, int plane_orientation);
 
double
computeUpsamplingFactor(const DEMInterpolator& dem_interp,
                        const isce3::product::RadarGridParameters& radar_grid,
                        const isce3::core::Ellipsoid& ellps);
 
std::string get_input_terrain_radiometry_str(
        rtcInputTerrainRadiometry input_terrain_radiometry);
std::string get_output_terrain_radiometry_str(
        rtcOutputTerrainRadiometry output_terrain_radiometry);
std::string get_rtc_area_mode_str(rtcAreaMode rtc_area_mode);
std::string get_rtc_area_beta_mode_str(rtcAreaBetaMode rtc_area_beta_mode);
std::string get_rtc_algorithm_str(rtcAlgorithm rtc_algorithm);
 
void print_parameters(pyre::journal::info_t& channel,
        const isce3::product::RadarGridParameters& radar_grid,
        rtcInputTerrainRadiometry input_terrain_radiometry,
        rtcOutputTerrainRadiometry output_terrain_radiometry,
        rtcAreaMode rtc_area_mode,
        rtcAreaBetaMode rtc_area_beta_mode,
        double geogrid_upsampling,
        float rtc_min_value_db);
}} // namespace isce3::geometry