ICU.h

#pragma once
 
#include <array> // std::array
#include <complex> // std::complex
#include <cstddef> // size_t
#include <cstdint> // uint8_t
 
#include <isce3/io/Raster.h> // isce3::io::Raster
 
#include "LabelMap.h" // LabelMap
 
namespace isce3::unwrap::icu
{
 
// 2-D index type
typedef std::array<size_t, 2> idx2_t;
 
// 2-D offset type
typedef std::array<int, 2> offset2_t;
 
class ICU
{
public:
    ICU() = default;

    ~ICU() = default;

    size_t numBufLines() const;
    void numBufLines(const size_t);

    size_t numOverlapLines() const;
    void numOverlapLines(const size_t);

    bool usePhaseGradNeut() const;
    void usePhaseGradNeut(const bool);

    bool useIntensityNeut() const;
    void useIntensityNeut(const bool);

    int phaseGradWinSize() const;
    void phaseGradWinSize(const int);

    float neutPhaseGradThr() const;
    void neutPhaseGradThr(const float);

    float neutIntensityThr() const;
    void neutIntensityThr(const float);

    float neutCorrThr() const;
    void neutCorrThr(const float);

    int numTrees() const;
    void numTrees(const int);

    int maxBranchLen() const;
    void maxBranchLen(const int);

    float ratioDxDy() const;
    void ratioDxDy(const float);

    float initCorrThr() const;
    void initCorrThr(const float);

    float maxCorrThr() const;
    void maxCorrThr(const float);

    float corrThrInc() const;
    void corrThrInc(const float);

    float minCCAreaFrac() const;
    void minCCAreaFrac(const float);

    size_t numBsLines() const;
    void numBsLines(const size_t);

    size_t minBsPts() const;
    void minBsPts(const size_t);

    float bsPhaseVarThr() const;
    void bsPhaseVarThr(const float);

    void unwrap(
        isce3::io::Raster & unw,
        isce3::io::Raster & ccl,
        isce3::io::Raster & intf,
        isce3::io::Raster & corr,
        unsigned int seed = 0);
 
    // Compute residue charges.
    void getResidues(
        signed char * charge, 
        const float * phase, 
        const size_t length, 
        const size_t width);
 
    // Generate neutrons to guide the tree growing process.
    void genNeutrons(
        bool * neut, 
        const std::complex<float> * intf,
        const float * corr,
        const size_t length, 
        const size_t width);
    
    // Grow trees (make branch cuts).
    void growTrees(
        bool * tree,
        const signed char * charge,
        const bool * neut, 
        const size_t length,
        const size_t width,
        const unsigned int seed = 0);
 
    // Grow grass (find connected components and unwrap phase).
    template<bool DO_BOOTSTRAP>
    void growGrass(
        float * unw,
        uint8_t * ccl,
        bool * currcc,
        float * bsunw,
        uint8_t * bsccl, 
        LabelMap & labelmap,
        const float * phase, 
        const bool * tree, 
        const float * corr, 
        float corrthr,
        const size_t length,
        const size_t width);
 
private:
    // Configuration params
    size_t _NumBufLines = 3700;
    size_t _NumOverlapLines = 200;
    bool _UsePhaseGradNeut = false;
    bool _UseIntensityNeut = false;
    int _PhaseGradWinSize = 5;
    float _NeutPhaseGradThr = 3.f;
    float _NeutIntensityThr = 8.f;
    float _NeutCorrThr = 0.8f;
    int _NumTrees = 7;
    int _MaxBranchLen = 64;
    float _RatioDxDy = 1.f;
    float _InitCorrThr = 0.1f;
    float _MaxCorrThr = 0.9f;
    float _CorrThrInc = 0.1f;
    float _MinCCAreaFrac = 0.003125f;
    size_t _NumBsLines = 16;
    size_t _MinBsPts = 16;
    float _BsPhaseVarThr = 8.f;
};
 
}
 
// Get inline implementations.
#define ISCE_UNWRAP_ICU_ICU_ICC
#include "ICU.icc"
#undef ISCE_UNWRAP_ICU_ICU_ICC