Swath.h

//-*- C++ -*-
//-*- coding: utf-8 -*-

#pragma once

// std
#include <valarray>

// isce3::core
#include <isce3/core/DateTime.h>
#include <isce3/core/LUT2d.h>
#include <isce3/core/Constants.h>

// isce3::io
#include <isce3/io/Raster.h>

// Declaration
namespace isce3 {
    namespace product {
        class Swath;
    }
}

// isce3::product::Swath definition
class isce3::product::Swath {

    public:
        // Constructors
        inline Swath() {};

        inline const std::valarray<double> & slantRange() const { return _slantRange; }
        inline void slantRange(const std::valarray<double> & rng) { _slantRange = rng; }

        inline double rangePixelSpacing() const { return _slantRange[1] - _slantRange[0]; }

        inline const std::valarray<double> & zeroDopplerTime() const { return _zeroDopplerTime; }
        inline void zeroDopplerTime(const std::valarray<double> & t) { _zeroDopplerTime = t; }

        inline size_t samples() const { return _slantRange.size(); }

        inline size_t lines() const { return _zeroDopplerTime.size(); }

        inline double acquiredCenterFrequency() const { return _acquiredCenterFrequency; }
        inline void acquiredCenterFrequency(double f) { _acquiredCenterFrequency = f; }

        inline double processedCenterFrequency() const { return _processedCenterFrequency; }
        inline void processedCenterFrequency(double f) { _processedCenterFrequency = f; }

        inline double processedWavelength() const {
            return isce3::core::speed_of_light / _processedCenterFrequency;
        }

        inline double acquiredRangeBandwidth() const { return _acquiredRangeBandwidth; }
        inline void acquiredRangeBandwidth(double b) { _acquiredRangeBandwidth = b; }

        inline double processedRangeBandwidth() const { return _processedRangeBandwidth; }
        inline void processedRangeBandwidth(double b) { _processedRangeBandwidth = b; }

        inline double nominalAcquisitionPRF() const { return _nominalAcquisitionPRF; }
        inline void nominalAcquisitionPRF(double f) { _nominalAcquisitionPRF = f; }

        inline double sceneCenterAlongTrackSpacing() const {
            return _sceneCenterAlongTrackSpacing;
        }
        inline void sceneCenterAlongTrackSpacing(double s) {
            _sceneCenterAlongTrackSpacing = s;
        }

        inline double sceneCenterGroundRangeSpacing() const {
            return _sceneCenterGroundRangeSpacing;
        }
        inline void sceneCenterGroundRangeSpacing(double s) {
            _sceneCenterGroundRangeSpacing = s;
        }

        inline double processedAzimuthBandwidth() const { return _processedAzimuthBandwidth; }
        inline void processedAzimuthBandwidth(double b) { _processedAzimuthBandwidth = b; }

        inline const isce3::core::DateTime & refEpoch() const { return _refEpoch; }
        inline void refEpoch(const isce3::core::DateTime & epoch) { _refEpoch = epoch; }

        inline std::array<size_t, 2> validSamples() const { return {_validStart, _validEnd}; }
        inline void validSamples(const std::array<size_t, 2> & valid) {
            _validStart = valid[0];
            _validEnd = valid[1];
        }

    private:
        // Coordinates
        std::valarray<double> _slantRange;
        std::valarray<double> _zeroDopplerTime;

        // Other metadata
        double _acquiredCenterFrequency;
        double _processedCenterFrequency;
        double _acquiredRangeBandwidth;
        double _processedRangeBandwidth;
        double _nominalAcquisitionPRF;
        double _sceneCenterAlongTrackSpacing;
        double _sceneCenterGroundRangeSpacing;
        double _processedAzimuthBandwidth;
        size_t _validStart;
        size_t _validEnd;

        // Reference epoch
        isce3::core::DateTime _refEpoch;
};