SubSwaths.h

//-*- C++ -*-
//-*- coding: utf-8 -*-
 
#pragma once
 
#include <string>
#include <vector>
#include <isce3/core/Matrix.h>
#include <isce3/except/Error.h>
 
namespace isce3 { namespace product {

class SubSwaths {
 
public:
    // Construct a new SubSwaths object. 
    inline SubSwaths() :
        _rlength(1),
        _rwidth(1) {};

     inline SubSwaths(const int length, const int width, const int n = 1) : 
        _rlength(length),
        _rwidth(width) {
            numSubSwaths(n);
    }

     inline SubSwaths(const int length, const int width,
                      const std::vector<isce3::core::Matrix<int>> & v) :
        _rlength(length),
        _rwidth(width) {
        setValidSamplesArraysVect(v);
    }

    inline int numSubSwaths() const { return _validSamplesArraysVect.size(); }
    inline void numSubSwaths(const int n) {
        if (n <= 0) {
            std::string error_msg =
                    "ERROR the number of sub-swaths must be greater than zero";
            throw isce3::except::OutOfRange(ISCE_SRCINFO(), error_msg);
        }
        _validSamplesArraysVect.resize(n, isce3::core::Matrix<int>());
        validate();
    };

    const isce3::core::Matrix<int>& getValidSamplesArray(const int n) const;

    void setValidSamplesArray(const int n, const isce3::core::Matrix<int>& v);

    const std::vector<isce3::core::Matrix<int>>& getValidSamplesArraysVect() const{
        return _validSamplesArraysVect;
    };

    void setValidSamplesArraysVect(const std::vector<isce3::core::Matrix<int>>& v){
        _validSamplesArraysVect = v;
        validate();
    };

    int getSampleSubSwath(const int azimuth_index, const int range_index) const;

    int operator()(const int azimuth_index, const int range_index) const {
        return getSampleSubSwath(azimuth_index, range_index);
    };

    inline int length() const { return _rlength; }

    inline void length(const int & t) {
        _rlength = t;
        validate();
    }

    inline int width() const { return _rwidth; }

    inline void width(const int & t) { 
        _rwidth = t;
        validate();
    }
 
private:

    int _rlength;

    int _rwidth;

    std::vector<isce3::core::Matrix<int>> _validSamplesArraysVect;

    inline void validate();
};
 
// Validation of SubSwaths attributes
void
isce3::product::SubSwaths::validate() {
 
    std::string error_str = "";
 
    if (length() <= 0)
    {
        error_str += "Number of azimuth lines must be positive. \n";
    }
 
    if (width() <= 0)
    {
        error_str += "Number of range samples must be positive. \n";
    }
 
    for (int s = 0; s < _validSamplesArraysVect.size(); ++s) {
        if (_validSamplesArraysVect[s].size() == 0) {
            continue;
        }
        if (_validSamplesArraysVect[s].width() != 2) {
            error_str += "The valid samples array of sub-swath ";
            error_str += std::to_string(s + 1);
            error_str += " does not have two columns. The";
            error_str += " columns should represent the indices";
            error_str += " of the first valid range sample and next";
            error_str += " sample after the last valid sample";
            error_str += " for each azimuth line, respectively.\n";
            continue;
        }
        if (_validSamplesArraysVect[s].length() != length()) {
            error_str += "The valid samples array of sub-swath ";
            error_str += std::to_string(s + 1);
            error_str += " has ";
            error_str += std::to_string(_validSamplesArraysVect[s].length());
            error_str += " lines whereas the number of azimuth lines is ";
            error_str += std::to_string(length());
            error_str += ".\n";
        }
        bool flag_informed_error_negative = false;
        bool flag_informed_error_width = false;
        for (int i = 0; i < length(); ++i) {
 
            for (int j = 0; j < 2; ++j) {

                if (_validSamplesArraysVect[s](i, j) < 0 and
                        !flag_informed_error_negative) {
                    error_str += "The valid samples array of sub-swath ";
                    error_str += std::to_string(s + 1);
                    error_str += " has negative indices. For example,";
                    error_str += " the array element at azimuth line ";
                    error_str += std::to_string(i);
                    error_str += " and column ";
                    error_str += std::to_string(j);
                    error_str += " has value ";
                    error_str += std::to_string(_validSamplesArraysVect[s](i, j));
                    error_str += ".\n";
                }
                if (_validSamplesArraysVect[s](i, j) > width() and
                        !flag_informed_error_width) {
                    error_str += "The valid samples array of sub-swath ";
                    error_str += std::to_string(s + 1);
                    error_str += " has invalid range indices.";
                    error_str += " The array element at azimuth line ";
                    error_str += std::to_string(i);
                    error_str += " and column ";
                    error_str += std::to_string(j);
                    error_str += " has value ";
                    error_str += std::to_string(_validSamplesArraysVect[s](i, j));
                    error_str += " which is invalid for the sub-swath with ";
                    error_str += std::to_string(width());
                    error_str += " range samples.\n";
                    flag_informed_error_width = true;
                }
 
            }
 
            // If both error messages were shown to the user, exit loop
            if (flag_informed_error_negative and flag_informed_error_width) {
                break;
            }
        }
    }
 
    if (! error_str.empty())
    {
        throw isce3::except::InvalidArgument(ISCE_SRCINFO(), error_str);
    }
}
 
 
}}