Topo.h

//-*- C++ -*-
//-*- coding: utf-8 -*-
//
// Author: Bryan Riel, Joshua Cohen
// Copyright 2017-2018

#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::Product &,
         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; }

    // Get topo processing options

    isce3::core::LookSide lookSide() const { return _lookSide; }

    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; }

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

    // Get DEM bounds using first/last azimuth line and slant range bin
    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,
              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);

    void topo(isce3::io::Raster& demRaster, 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);

    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);

    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);

    void setLayoverShadow(TopoLayers&, DEMInterpolator&,
                          std::vector<isce3::core::Vec3>&);

    // 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, 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);

    template<typename T>
    void _topo(T& dem, 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::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::LookSide _lookSide;

    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