ResampSlc.icc

// Since fmod(a,b) in C++ != MODULO(a,b) in Fortran for all a,b, define a C++
// equivalent
#define modulo_f(a, b) fmod(fmod(a, b) + (b), (b))
 
namespace isce3 { namespace image {
 
// Constructor from an isce3::product::RadarGridProduct
inline ResampSlc::ResampSlc(const isce3::product::RadarGridProduct& product,
                            char frequency, const std::complex<float> invalid_value)
    : ResampSlc(product.swath(frequency), invalid_value)
{
    // Set the doppler
    _dopplerLUT = product.metadata().procInfo().dopplerCentroid(frequency);
    // Save the filename
    _filename = product.filename();
}
 
// Constructor from an isce3::product::RadarGridProduct and reference product
// (flattening)
inline ResampSlc::ResampSlc(const isce3::product::RadarGridProduct& product,
                            const isce3::product::RadarGridProduct& refProduct,
                            char frequency, const std::complex<float> invalid_value)
    : ResampSlc(product.swath(frequency), refProduct.swath(frequency),
                invalid_value)
{
    // Set the doppler
    _dopplerLUT = product.metadata().procInfo().dopplerCentroid(frequency);
    // Save the filename
    _filename = product.filename();
}
 
// Constructor from an isce3::product::Swath (no flattening)
inline ResampSlc::ResampSlc(const isce3::product::Swath& swath,
                            const std::complex<float> invalid_value)
    : _haveRefData(false), _invalid_value(invalid_value)
{
    // Set radar parameters
    _setDataFromSwath(swath);
}
 
// Constructor from an isce3::product::Swath and reference swath (flattening)
inline ResampSlc::ResampSlc(const isce3::product::Swath& swath,
                            const isce3::product::Swath& refSwath,
                            const std::complex<float> invalid_value)
    : _haveRefData(true), _invalid_value(invalid_value)
{
    // Set radar parameters
    _setDataFromSwath(swath);
    // Set reference radar parameters
    _setRefDataFromSwath(refSwath);
}
 
// Constructor from an isce3::product::RadarGridParameters (no flattening)
inline ResampSlc::ResampSlc(const isce3::product::RadarGridParameters& rdr_grid,
                            const isce3::core::LUT2d<double>& doppler,
                            const std::complex<float> invalid_value)
    : _haveRefData(false), _dopplerLUT(doppler),
      _startingRange(rdr_grid.startingRange()),
      _rangePixelSpacing(rdr_grid.rangePixelSpacing()),
      _sensingStart(rdr_grid.sensingStart()), _prf(rdr_grid.prf()),
      _wavelength(rdr_grid.wavelength()), _invalid_value(invalid_value)
{}
 
// Constructor from an isce3::product::RadarGridParameters and reference radar
// grid (flattening)
inline ResampSlc::ResampSlc(
        const isce3::product::RadarGridParameters& rdr_grid,
        const isce3::product::RadarGridParameters& ref_rdr_grid,
        const isce3::core::LUT2d<double>& doppler,
        const std::complex<float> invalid_value)
    : _haveRefData(true), _dopplerLUT(doppler),
      _startingRange(rdr_grid.startingRange()),
      _rangePixelSpacing(rdr_grid.rangePixelSpacing()),
      _sensingStart(rdr_grid.sensingStart()), _prf(rdr_grid.prf()),
      _wavelength(rdr_grid.wavelength()),
      _refStartingRange(ref_rdr_grid.startingRange()),
      _refRangePixelSpacing(ref_rdr_grid.rangePixelSpacing()),
      _refWavelength(ref_rdr_grid.wavelength()), _invalid_value(invalid_value)
{}
 
// Constructor from individual components (no flattening)
inline ResampSlc::ResampSlc(const isce3::core::LUT2d<double>& doppler,
                            double startingRange, double rangePixelSpacing,
                            double sensingStart, double prf, double wvl,
                            const std::complex<float> invalid_value)
    : _haveRefData(false), _dopplerLUT(doppler), _startingRange(startingRange),
      _rangePixelSpacing(rangePixelSpacing), _sensingStart(sensingStart),
      _prf(prf), _wavelength(wvl), _invalid_value(invalid_value)
{}
 
// Constructor from individual components (flattening)
inline ResampSlc::ResampSlc(const isce3::core::LUT2d<double>& doppler,
                            double startingRange, double rangePixelSpacing,
                            double sensingStart, double prf, double wvl,
                            double refStartingRange,
                            double refRangePixelSpacing, double refWvl,
                            const std::complex<float> invalid_value)
    : _haveRefData(true), _dopplerLUT(doppler), _startingRange(startingRange),
      _rangePixelSpacing(rangePixelSpacing), _sensingStart(sensingStart),
      _prf(prf), _wavelength(wvl), _refStartingRange(refStartingRange),
      _refRangePixelSpacing(refRangePixelSpacing), _refWavelength(refWvl),
      _invalid_value(invalid_value)
{}
 
// Set radar parameters from an isce3::product::Swath
inline void ResampSlc::_setDataFromSwath(const isce3::product::Swath& swath)
{
    _startingRange = swath.slantRange()[0];
    _rangePixelSpacing = swath.rangePixelSpacing();
    _sensingStart = swath.zeroDopplerTime()[0];
    _prf = 1.0 / swath.zeroDopplerTimeSpacing();
    _wavelength = swath.processedWavelength();
}
 
// Set reference radar parameters from an isce3::product::Swath (for flattening)
inline void ResampSlc::_setRefDataFromSwath(const isce3::product::Swath& swath)
{
    _refStartingRange = swath.slantRange()[0];
    _refRangePixelSpacing = swath.rangePixelSpacing();
    _refWavelength = swath.processedWavelength();
}
 
// Get range carrier polynomial
inline isce3::core::Poly2d ResampSlc::rgCarrier() const { return _rgCarrier; }
 
// Set range carrier polynomial
inline void ResampSlc::rgCarrier(const isce3::core::Poly2d& lut)
{
    _rgCarrier = lut;
}
 
// Get azimuth carrier polynomial
inline isce3::core::Poly2d ResampSlc::azCarrier() const { return _azCarrier; }
 
// Set azimuth carrier polynomial
inline void ResampSlc::azCarrier(const isce3::core::Poly2d& lut)
{
    _azCarrier = lut;
}
 
// Get read-only reference to Doppler LUT
inline const isce3::core::LUT2d<double>& ResampSlc::doppler() const
{
    return _dopplerLUT;
}
 
// Get reference to Doppler LUT
inline isce3::core::LUT2d<double>& ResampSlc::doppler() { return _dopplerLUT; }
 
// Set Doppler LUT
inline void ResampSlc::doppler(const isce3::core::LUT2d<double>& lut)
{
    _dopplerLUT = lut;
}
 
// Set reference product
inline void
ResampSlc::referenceProduct(const isce3::product::RadarGridProduct& refProduct,
                            char frequency)
{
    _setRefDataFromSwath(refProduct.swath(frequency));
    _haveRefData = true;
}
 
// Announce my properties to the world
inline void ResampSlc::declare(size_t inLength, size_t inWidth, size_t outLength,
                               size_t outWidth) const
{
    // Make info channel
    pyre::journal::info_t channel("isce.core.ResampSlc");
    // Basic info
    channel << pyre::journal::newline
            << "Resample one image to another image coordinates >>"
            << pyre::journal::newline << pyre::journal::newline;
    channel << "Input Image Dimensions:  " << inLength << " lines, " << inWidth
            << " pixels" << pyre::journal::newline;
    channel << "Output Image Dimensions: " << outLength << " lines, "
            << outWidth << " pixels" << pyre::journal::newline
            << pyre::journal::newline;
    channel << "Complex data interpolation" << pyre::journal::newline;
}
 
// Get the number of lines per tile
inline size_t ResampSlc::linesPerTile() const { return _linesPerTile; }
 
// Set the number of lines per tile
inline void ResampSlc::linesPerTile(size_t value) { _linesPerTile = value; }
 
// Compute number of tiles given a specified nominal tile size
inline size_t ResampSlc::_computeNumberOfTiles(size_t outLength, size_t linesPerTile)
{
    // Compute floor(nTiles)
    size_t nTiles = outLength / linesPerTile;
    // See if there are any leftover lines to add an extra tile
    size_t extraLines = outLength - nTiles * linesPerTile;
    if (extraLines > 0) {
        nTiles += 1;
    }
    return nTiles;
}
 
// Prepare interpolation pointer
inline void ResampSlc::_prepareInterpMethods(isce3::core::dataInterpMethod,
                                             int sinc_len)
{
    _interp = new isce3::core::Sinc2dInterpolator<std::complex<float>>(
            sinc_len, isce3::core::SINC_SUB);
}
 
}} // namespace isce3::image