RadarGeometry.icc

#include <isce3/except/Error.h>
#include <limits>
 
namespace isce3 {
namespace container {
 
inline RadarGeometry::RadarGeometry(const RadarGridParameters& radar_grid,
                                    const Orbit& orbit,
                                    const LUT2d<double>& doppler)
:
    _radar_grid(radar_grid),
    _orbit(orbit),
    _doppler(doppler)
{
    if (_radar_grid.refEpoch() != _orbit.referenceEpoch()) {
        auto old_refepoch = _radar_grid.refEpoch();
        auto new_refepoch = _orbit.referenceEpoch();
 
        auto old_sensing_start = _radar_grid.sensingStart();
        auto dt = (old_refepoch - new_refepoch).getTotalSeconds();
        auto new_sensing_start = old_sensing_start + dt;
 
        _radar_grid.refEpoch(new_refepoch);
        _radar_grid.sensingStart(new_sensing_start);
    }
}
 
inline isce3::core::Linspace<double> RadarGeometry::sensingTime() const
{
    // check for overflow when converting gridLength() -> int
    constexpr static auto maxint =
            static_cast<size_t>(std::numeric_limits<int>::max());
    if (gridLength() > maxint) {
        using isce3::except::OverflowError;
        throw OverflowError(ISCE_SRCINFO(), "grid length exceeds max int");
    }
 
    auto t0 = radarGrid().sensingStart();
    auto dt = radarGrid().azimuthTimeInterval();
    auto lines = static_cast<int>(gridLength());
    return {t0, dt, lines};
}
 
inline isce3::core::Linspace<double> RadarGeometry::slantRange() const
{
    // check for overflow when converting gridWidth() -> int
    constexpr static auto maxint =
            static_cast<size_t>(std::numeric_limits<int>::max());
    if (gridWidth() > maxint) {
        using isce3::except::OverflowError;
        throw OverflowError(ISCE_SRCINFO(), "grid width exceeds max int");
    }
 
    auto r0 = radarGrid().startingRange();
    auto dr = radarGrid().rangePixelSpacing();
    auto samples = static_cast<int>(gridWidth());
    return {r0, dr, samples};
}
 
} // namespace container
} // namespace isce3