Grid.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>
 
// isce3::product
#include <isce3/product/GeoGridParameters.h>
 
// Declaration
namespace isce3 {
    namespace product {
 

class Grid {
 
    public:
        // Constructors
        inline Grid() {};

        inline double rangeBandwidth() const { return _rangeBandwidth; }
        inline void rangeBandwidth(double b) { _rangeBandwidth = b; }

        inline double azimuthBandwidth() const { return _azimuthBandwidth; }
        inline void azimuthBandwidth(double b) { _azimuthBandwidth = b; }

        inline double centerFrequency() const { return _centerFrequency; }
        inline void centerFrequency(double f) { _centerFrequency = f; }

        inline double wavelength() const {
            return isce3::core::speed_of_light / _centerFrequency;
        }

        inline double slantRangeSpacing() const {
            return _slantRangeSpacing;
        }

        inline void slantRangeSpacing(double s) {
            _slantRangeSpacing = s;
        }

        inline isce3::product::GeoGridParameters geogrid() { 
            return _geogrid; 
        }

        inline void geogrid(isce3::product::GeoGridParameters geogrid) { 
            _geogrid = geogrid;
        }

        inline double zeroDopplerTimeSpacing() const { return _zeroDopplerTimeSpacing; }
        inline void zeroDopplerTimeSpacing(double dt) { _zeroDopplerTimeSpacing = dt; }
 
        /* Geogrid parameters */

        inline double startX() const { return _geogrid.startX(); }
        inline void startX(double val) { _geogrid.startX(val); }

        inline double startY() const { return _geogrid.startY(); }
        inline void startY(double val) { _geogrid.startY(val);}

        inline double spacingX() const { return _geogrid.spacingX(); }
        inline void spacingX(double val) { _geogrid.spacingX(val); }

        inline double spacingY() const { return _geogrid.spacingY(); }
        inline void spacingY(double val) { _geogrid.spacingY(val);}

        inline size_t width() const { return _geogrid.width(); }
        inline void width(int w) { _geogrid.width(w); }

        inline size_t length() const { return _geogrid.length(); }
        //** Set number of pixels in east-west/x direction for geocoded grid */
        inline void length(int l) { _geogrid.length(l); }

        inline size_t epsg() const { return _geogrid.epsg(); }
        //** Set epsg code for geocoded grid */
        inline void epsg(int l) { _geogrid.epsg(l); }
 
 
    private:
 
        // Other metadata
        isce3::product::GeoGridParameters _geogrid;
        double _rangeBandwidth = std::numeric_limits<double>::quiet_NaN();
        double _azimuthBandwidth = std::numeric_limits<double>::quiet_NaN();
        double _slantRangeSpacing = std::numeric_limits<double>::quiet_NaN();
        double _zeroDopplerTimeSpacing = std::numeric_limits<double>::quiet_NaN();
        double _centerFrequency = std::numeric_limits<double>::quiet_NaN();
 
};
 
 
    }
}