DEMInterpolator.h

// -*- C++ -*-
// -*- coding: utf-8 -*-
//
// Author: Bryan Riel
// Copyright 2017-2018
 
#pragma once
 
#include <memory>
#include <string>
#include "forward.h"
 
// pyre
#include <pyre/journal.h>
 
// isce3::core
#include <isce3/core/forward.h>
#include <isce3/io/forward.h>
 
#include <isce3/core/Constants.h>
#include <isce3/core/Interpolator.h>
#include <isce3/error/ErrorCode.h>
 
// DEMInterpolator declaration
class isce3::geometry::DEMInterpolator {
 
    using cartesian_t = isce3::core::Vec3;
 
    public:
        inline DEMInterpolator(float height = 0.0, int epsg = 4326) :
            _haveRaster{false},
            _refHeight{height},
            _haveStats{true},
            _minValue{height},
            _meanValue{height},
            _maxValue{height},
            _epsgcode{epsg},
            _interpMethod{isce3::core::BILINEAR_METHOD} {}

        inline DEMInterpolator(float height,
                               isce3::core::dataInterpMethod method,
                               int epsg = 4326) :
            _haveRaster{false},
            _refHeight{height},
            _haveStats{true},
            _minValue{height},
            _meanValue{height},
            _maxValue{height},
            _epsgcode{epsg},
            _interpMethod{method} {}

        isce3::error::ErrorCode loadDEM(isce3::io::Raster& demRaster,
                double min_x, double max_x, double min_y, double max_y,
                const int dem_raster_band = 1);

        void loadDEM(isce3::io::Raster &demRaster,
                     const int dem_raster_band = 1);
 
        // Print stats
        void declare() const;

        void computeMinMaxMeanHeight(float &minValue, float &maxValue,
                                     float &meanValue);

        double interpolateLonLat(double lon, double lat) const;
        double interpolateXY(double x, double y) const;

        double xStart() const { return _xstart; }
        void xStart(double xstart) { _xstart = xstart; }

        double yStart() const { return _ystart; }
        void yStart(double ystart) { _ystart = ystart; }

        double deltaX() const { return _deltax; }
        void deltaX(double deltax) { _deltax = deltax; }

        double deltaY() const { return _deltay; }
        void deltaY(double deltay) { _deltay = deltay; }

        double midX() const { return _xstart + 0.5*width()*_deltax; }
        double midY() const { return _ystart + 0.5*length()*_deltay; }
        cartesian_t midLonLat() const;

        bool haveRaster() const { return _haveRaster; }

        double refHeight() const { return _refHeight; }
        void refHeight(double h) {
            _refHeight = h;
            if (not haveRaster()) {
                _minValue = h;
                _meanValue = h;
                _maxValue = h;
            }
        }

        bool haveStats() const { return _haveStats; }

        inline float meanHeight() const {
            validateStatsAccess("meanHeight");
            return _meanValue;
        }

        inline float maxHeight() const {
            validateStatsAccess("maxHeight");
            return _maxValue;
        }

        inline float minHeight() const {
            validateStatsAccess("minHeight");
            return _minValue;
        }

        float * data() { return _dem.data(); }

        const float* data() const { return _dem.data(); }

        inline size_t width() const { return (_haveRaster ? _dem.width() : _width); }
        inline void width(int width) { _width = width; }

        inline size_t length() const { return (_haveRaster ? _dem.length() : _length); }
        inline void length(int length) { _length = length; }

        inline int epsgCode() const { return _epsgcode; }
        void epsgCode(int epsgcode);

        inline isce3::core::ProjectionBase* proj() const {return _proj.get(); }

        inline isce3::core::dataInterpMethod interpMethod() const {
            return _interpMethod;
        }

        inline void interpMethod(isce3::core::dataInterpMethod interpMethod) {
            _interpMethod = interpMethod;
        }
 
    private:
        // Flag indicating whether we have access to a DEM raster
        bool _haveRaster;
        // Constant value if no raster is provided
        float _refHeight;
        // Statistics
        bool _haveStats;
        float _minValue;
        float _meanValue;
        float _maxValue;
        // Pointer to a ProjectionBase
        int _epsgcode;
        std::shared_ptr<isce3::core::ProjectionBase> _proj;
        // Pointer to an Interpolator
        isce3::core::dataInterpMethod _interpMethod;
        std::shared_ptr<isce3::core::Interpolator<float>> _interp;
        // 2D array for storing DEM subset
        isce3::core::Matrix<float> _dem;
        // Starting x/y for DEM subset and spacing
        double _xstart, _ystart, _deltax, _deltay;
        int _width, _length;
 
        // Check if stats are accessed before they're computed.
        void validateStatsAccess(const std::string& method) const;
};