Grid2DObject.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
/***********************************************************************************/
/*  Copyright 2009 WSL Institute for Snow and Avalanche Research    SLF-DAVOS      */
/***********************************************************************************/
/* This file is part of MeteoIO.
    MeteoIO is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    MeteoIO is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with MeteoIO.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRID2DOBJECT_H
#define GRID2DOBJECT_H
 
#include <meteoio/dataClasses/Coords.h>
#include <meteoio/dataClasses/StationData.h>
#include <meteoio/dataClasses/Array2D.h>
 
#include <iostream>
 
namespace mio {
 
class IOInterface;
class GridsManager;
 
class Grid2DObject {
        friend class IOInterface;
        friend class GridsManager;
        
        public:
                typedef struct GRID_POINT_2D {
                        size_t ix; 
                        size_t iy; 
                } grid_point_2d;
 
                double& operator ()(const size_t& ix, const size_t& iy);
                double operator ()(const size_t& ix, const size_t& iy) const;
                double& operator ()(const size_t& i);
                double operator ()(const size_t& i) const;
 
                const std::string toString() const;
                friend std::ostream& operator<<(std::ostream& os, const Grid2DObject& grid);
                friend std::istream& operator>>(std::istream& is, Grid2DObject& grid);
 
                Grid2DObject();
                Grid2DObject(const size_t& ncols, const size_t& nrows,
                             const double& cellsize, const Coords& i_llcorner);
 
                Grid2DObject(const size_t& ncols, const size_t& nrows,
                             const double& cellsize, const Coords& i_llcorner, const double& init);
 
                Grid2DObject(const Grid2DObject& i_grid, const double& init);
 
                Grid2DObject(const double& cellsize, const Coords& i_llcorner, const Array2D<double>& grid2D_in);
 
                Grid2DObject(const Grid2DObject& i_grid2Dobj,
                             const size_t& i_nx, const size_t& i_ny, //Point in the plane
                             const size_t& i_ncols, const size_t& i_nrows); //dimensions of the sub-plane
 
                bool gridify(Coords& point) const;
 
                bool gridify(std::vector<Coords>& vec_points, const bool& keep_invalid=false) const;
                bool gridify(std::vector<StationData>& vec_points, const bool& keep_invalid=false) const;
 
                void set(const size_t& ncols, const size_t& nrows,
                         const double& cellsize, const Coords& i_llcorner);
                void set(const double& cellsize, const Coords& i_llcorner, const Array2D<double>& grid2D_in);
 
                void set(const size_t& ncols, const size_t& nrows,
                         const double& cellsize, const Coords& i_llcorner, const double& init);
 
                void set(const Grid2DObject& i_grid, const double& init);
                
                void rescale(const double& i_cellsize);
 
                void compute_spatial_mean(const double& radius);
        
                void size(size_t& o_ncols, size_t& o_nrows) const;
                size_t size() const;
                size_t getNx() const;
                size_t getNy() const;
                double getMin() const;
                double getMax() const;
                double getMean() const;
 
                void clear();
 
                bool empty() const;
 
                bool allNodata() const;
 
                bool isSameGeolocalization(const Grid2DObject& target) const;
 
                void binning(const std::vector<double>& thresholds, const std::vector<double>& ids);
 
                std::vector< double > extractPoints(const std::vector< std::pair<size_t, size_t> >& Pts) const;
 
                Grid2DObject& operator=(const double& value); 
 
                Grid2DObject& operator+=(const double& rhs);
                const Grid2DObject operator+(const double& rhs) const;
                Grid2DObject& operator+=(const Grid2DObject& rhs);
                const Grid2DObject operator+(const Grid2DObject& rhs) const;
 
                Grid2DObject& operator-=(const double& rhs);
                const Grid2DObject operator-(const double& rhs) const;
                Grid2DObject& operator-=(const Grid2DObject& rhs);
                const Grid2DObject operator-(const Grid2DObject& rhs) const;
 
                Grid2DObject& operator*=(const double& rhs);
                const Grid2DObject operator*(const double& rhs) const;
                Grid2DObject& operator*=(const Grid2DObject& rhs);
                const Grid2DObject operator*(const Grid2DObject& rhs) const;
 
                Grid2DObject& operator/=(const double& rhs);
                const Grid2DObject operator/(const double& rhs) const;
                Grid2DObject& operator/=(const Grid2DObject& rhs);
                const Grid2DObject operator/(const Grid2DObject& rhs) const;
 
                bool operator==(const Grid2DObject& in) const; 
                bool operator!=(const Grid2DObject& in) const; 
 
                Array2D<double> grid2D; 
                Coords llcorner; 
                double cellsize; 
 
 protected:
                void setValues(const double& cellsize, const Coords& i_llcorner);
 
                bool WGS84_to_grid(Coords& point) const;
 
                bool grid_to_WGS84(Coords& point) const;
                
                bool isLatlon() const {return isLatLon;}
                
                void reproject();
 
                static double calculate_XYcellsize(const std::vector<double>& vecX, const std::vector<double>& vecY);
                double calculate_cellsize(const double& i_ur_lat, const double& i_ur_lon) const;
                void setLatLon(const double& i_ur_lat, const double& i_ur_lon) {ur_lat=i_ur_lat; ur_lon=i_ur_lon; isLatLon=true;}
                
                double ur_lat, ur_lon;
                bool isLatLon;
};
} //end namespace
 
#endif