multilook.h

#pragma once

#include <isce3/core/EMatrix.h>

namespace isce3 {
namespace signal {

template<typename EigenT1, typename EigenT2>
auto multilookWeightedAvg(const EigenT1& input, int row_looks, int col_looks,
                          const EigenT2& weights)
{

    const auto nrows = input.rows() / row_looks;
    const auto ncols = input.cols() / col_looks;

    using value_type = typename EigenT1::value_type;
    isce3::core::EArray2D<value_type> output(nrows, ncols);

    #pragma omp parallel for collapse(2)
    for (int row = 0; row < nrows; ++row) {
        for (int col = 0; col < ncols; ++col) {

            const auto cells = input.block(row * row_looks, col * col_looks,
                                           row_looks, col_looks);
            const auto wgts = weights.block(row * row_looks, col * col_looks,
                                            row_looks, col_looks);

            output(row, col) = (cells * wgts).sum() / wgts.sum();
        }
    }

    return output;
}

template<typename EigenType>
auto multilookSummed(const EigenType& input, int row_looks, int col_looks)
{

    const auto nrows = input.rows() / row_looks;
    const auto ncols = input.cols() / col_looks;

    using value_type = typename EigenType::value_type;
    isce3::core::EArray2D<value_type> output(nrows, ncols);

    #pragma omp parallel for collapse(2)
    for (int row = 0; row < nrows; ++row) {
        for (int col = 0; col < ncols; ++col) {

            output(row, col) = input.block(row * row_looks, col * col_looks,
                                           row_looks, col_looks)
                                       .sum();
        }
    }

    return output;
}

template<typename EigenType>
auto multilookAveraged(const EigenType& input, int row_looks, int col_looks)
{

    const auto nrows = input.rows() / row_looks;
    const auto ncols = input.cols() / col_looks;

    using value_type = typename EigenType::value_type;
    isce3::core::EArray2D<value_type> output(nrows, ncols);

    #pragma omp parallel for collapse(2)
    for (int row = 0; row < nrows; ++row) {
        for (int col = 0; col < ncols; ++col) {

            output(row, col) = input.block(row * row_looks, col * col_looks,
                                           row_looks, col_looks)
                                       .mean();
        }
    }

    return output;
}

template<typename EigenInput>
auto multilookNoData(const EigenInput& input, int row_looks, int col_looks,
                     const typename EigenInput::value_type nodata)
{

    auto upcast_bool = [](const bool b) {
        typename EigenInput::value_type ret = b ? 1 : 0;
        return ret;
    };

    auto weights = (input != nodata).unaryExpr(upcast_bool);

    return multilookWeightedAvg(input, row_looks, col_looks, weights);
}

template<typename EigenInput>
auto multilookPow(const EigenInput& input, int row_looks, int col_looks,
                  const int exponent)
{

    return multilookAveraged(input.abs().pow(exponent), row_looks, col_looks);
}

} // namespace signal
} // namespace isce3