Topo.h

#pragma once
 
#include "forward.h"
 
#include <isce3/core/forward.h>
#include <isce3/core/Ellipsoid.h>
#include <isce3/core/LUT2d.h>
#include <isce3/core/Orbit.h>
 
// isce3::io
#include <isce3/io/forward.h>
 
// isce3::product
#include <isce3/product/forward.h>
#include <isce3/product/RadarGridParameters.h>
 
// isce3::geometry
#include "geometry.h"

class isce3::geometry::Topo {
public:

    Topo(const isce3::product::RadarGridProduct &,
         char frequency = 'A',
         bool nativeDoppler = false);

    Topo(const isce3::product::RadarGridParameters & radarGrid,
         const isce3::core::Orbit & orbit,
         const isce3::core::Ellipsoid & ellipsoid,
         const isce3::core::LUT2d<double> & doppler = {});

    Topo(const isce3::core::Ellipsoid & ellipsoid,
         const isce3::core::Orbit & orbit,
         const isce3::core::LUT2d<double> & doppler,
         const isce3::core::Metadata & meta);

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

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

    void extraiter(int n) { _extraiter = n; }

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

    void epsgOut(int epsgcode);

    void computeMask(bool mask) { _computeMask = mask; }

    void minimumHeight(double minh) { _minH = minh; }

    void maximumHeight(double maxh) { _maxH = maxh; }

    void decimaldegMargin(double deg) { _margin = deg; }

    void linesPerBlock(size_t linesPerBlock) { _linesPerBlock = linesPerBlock; }
 
    // Get topo processing options

    double threshold() const { return _threshold; }

    int numiter() const { return _numiter; }

    int extraiter() const { return _extraiter; }

    int epsgOut() const { return _epsgOut; }

    isce3::core::dataInterpMethod demMethod() const { return _demMethod; }

    bool computeMask() const { return _computeMask; }

    double minimumHeight() const { return _minH; }

    double maximumHeight() const { return _maxH; }

    double decimaldegMargin() const { return _margin; }

    size_t linesPerBlock() const { return _linesPerBlock; }

    const isce3::product::RadarGridParameters & radarGridParameters() const { return _radarGrid; }

    void computeDEMBounds(isce3::io::Raster &, DEMInterpolator &, size_t, size_t);

    void topo(isce3::io::Raster& demRaster, const std::string& outdir);

    void topo(isce3::io::Raster & demRaster, TopoLayers & layers);

    void topo(isce3::io::Raster& demRaster,
              isce3::io::Raster* xRaster = nullptr,
              isce3::io::Raster* yRaster = nullptr,
              isce3::io::Raster* heightRaster = nullptr,
              isce3::io::Raster* incRaster = nullptr,
              isce3::io::Raster* hdgRaster = nullptr,
              isce3::io::Raster* localIncRaster = nullptr,
              isce3::io::Raster* localPsiRaster = nullptr,
              isce3::io::Raster* simRaster = nullptr,
              isce3::io::Raster* maskRaster = nullptr,
              isce3::io::Raster* groundToSatEastRaster = nullptr,
              isce3::io::Raster* groundToSatNorthRaster = nullptr);

    void topo(isce3::geometry::DEMInterpolator& demInterp,
              const std::string& outdir);

    void topo(isce3::geometry::DEMInterpolator& demInterp, TopoLayers& layers);

    void topo(isce3::geometry::DEMInterpolator& demInterp,
              isce3::io::Raster* xRaster,
              isce3::io::Raster* yRaster,
              isce3::io::Raster* heightRaster,
              isce3::io::Raster* incRaster,
              isce3::io::Raster* hdgRaster,
              isce3::io::Raster* localIncRaster,
              isce3::io::Raster* localPsiRaster,
              isce3::io::Raster* simRaster,
              isce3::io::Raster* maskRaster,
              isce3::io::Raster* groundToSatEastRaster,
              isce3::io::Raster* groundToSatNorthRaster);

    void setLayoverShadow(TopoLayers&, DEMInterpolator&,
                          std::vector<isce3::core::Vec3>&,
                          size_t block,
                          size_t n_blocks);
 
    // Getters for isce objects

    inline const isce3::core::Orbit& orbit() const { return _orbit; }
    inline const isce3::core::Ellipsoid& ellipsoid() const { return _ellipsoid; }
    inline const isce3::core::LUT2d<double>& doppler() const { return _doppler; }
 
private:
    void _initAzimuthLine(size_t line, double&,
                          isce3::core::Vec3& pos, isce3::core::Vec3& vel,
                          isce3::core::Basis& TCNbasis);

    void _setOutputTopoLayers(isce3::core::Vec3 &,
                              TopoLayers &,
                              size_t,
                              isce3::core::Pixel &,
                              isce3::core::Vec3& pos,
                              isce3::core::Vec3& vel,
                              isce3::core::Basis &,
                              DEMInterpolator &);

    template<typename T> void _topo(T& dem, const std::string& outdir);

    template<typename T>
    void _topo(T& dem,
               isce3::io::Raster* xRaster = nullptr,
               isce3::io::Raster* yRaster = nullptr,
               isce3::io::Raster* heightRaster = nullptr,
               isce3::io::Raster* incRaster = nullptr,
               isce3::io::Raster* hdgRaster = nullptr,
               isce3::io::Raster* localIncRaster = nullptr,
               isce3::io::Raster* localPsiRaster = nullptr,
               isce3::io::Raster* simRaster = nullptr,
               isce3::io::Raster* maskRaster = nullptr,
               isce3::io::Raster* groundToSatEastRaster = nullptr,
               isce3::io::Raster* groundToSatNorthRaster = nullptr);
 
    // isce3::core objects
    isce3::core::Orbit _orbit;
    isce3::core::Ellipsoid _ellipsoid;
    isce3::core::LUT2d<double> _doppler;
 
    // RadarGridParameters
    isce3::product::RadarGridParameters _radarGrid;
 
    // Optimization options
    double _threshold = 1.0e-8;   //Threshold for convergence of slant range
    int _numiter = 25;            //Number of primary iterations
    int _extraiter = 10;          //Number of secondary iterations
    double _minH = isce3::core::GLOBAL_MIN_HEIGHT;   //Lowest altitude in scene (global minimum default)
    double _maxH = isce3::core::GLOBAL_MAX_HEIGHT;   //Highest altitude in scene (global maximum default)
    double _margin = 0.15;        //Margin for bounding box in decimal degrees
    size_t _linesPerBlock = 1000; //Block size for processing
    bool _computeMask = true;     //Flag for generating shadow-layover mask
 
    isce3::core::dataInterpMethod _demMethod;
 
    // Output options and objects
    int _epsgOut;
    isce3::core::ProjectionBase * _proj;
};
 
// Get inline implementations for Topo
#define ISCE_GEOMETRY_TOPO_ICC
#include "Topo.icc"
#undef ISCE_GEOMETRY_TOPO_ICC