Grid3DObject.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 GRID3DOBJECT_H
#define GRID3DOBJECT_H
 
#include <meteoio/dataClasses/Coords.h>
#include <meteoio/dataClasses/Array3D.h>
#include <meteoio/dataClasses/Grid2DObject.h>
 
#include <iostream>
 
namespace mio {
 
class Grid3DObject{
        public:
                typedef struct GRID_POINT_3D { //TODO: this potentially conflicts with the definition in Grid2DObject
                        size_t ix; 
                        size_t iy; 
                        size_t iz; 
                } grid_point_3d;
 
                double& operator ()(const size_t& ix, const size_t& iy, const size_t& iz);
                double operator ()(const size_t& ix, const size_t& iy, const size_t& iz) 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 Grid3DObject& grid);
                friend std::istream& operator>>(std::istream& is, Grid3DObject& grid);
 
                Grid3DObject();
 
                Grid3DObject(const Grid3DObject& i_grid3D,
                             const size_t& i_nx, const size_t& i_ny, const size_t& i_nz,
                             const size_t& i_ncols, const size_t& i_nrows, const size_t& i_ndepths);
 
                Grid3DObject(const size_t& ncols, const size_t& nrows, const size_t& ndepths,
                             const double& cellsize, const Coords& i_llcorner);
 
                Grid3DObject(const size_t& ncols, const size_t& nrows, const size_t& ndepths,
                             const double& cellsize, const Coords& i_llcorner, const double& init);
 
                Grid3DObject(const Grid3DObject& i_grid, const double& init);
 
                Grid3DObject(const double& cellsize, const Coords& i_llcorner, const Array3D<double>& grid3D);
 
                void set(const size_t& ncols, const size_t& nrows, const size_t& depths,
                         const double& cellsize, const Coords& i_llcorner);
                void set(const double& cellsize, const Coords& i_llcorner, const Array3D<double>& grid3D_in);
 
                void set(const size_t& ncols, const size_t& nrows, const size_t& ndepths,
                         const double& cellsize, const Coords& i_llcorner, const double& init);
 
                void set(const Grid3DObject& i_grid, const double& init);
 
                void size(size_t& o_ncols, size_t& o_nrows, size_t& o_ndepths) const;
                size_t size() const;
                size_t getNx() const;
                size_t getNy() const;
                size_t getNz() const;
 
                void clear();
 
                bool empty() const;
 
                bool gridify(Coords& point) const;
 
                bool gridify(std::vector<Coords>& vec_points, const bool& keep_invalid=false) const;
 
                bool isSameGeolocalization(const Grid3DObject& target) const;
 
                void extractLayer(const size_t& i_z, Grid2DObject& layer);
 
                Grid3DObject& operator=(const double& value); 
 
                Grid3DObject& operator+=(const double& rhs);
                const Grid3DObject operator+(const double& rhs) const;
                Grid3DObject& operator+=(const Grid3DObject& rhs);
                const Grid3DObject operator+(const Grid3DObject& rhs) const;
 
                Grid3DObject& operator-=(const double& rhs);
                const Grid3DObject operator-(const double& rhs) const;
                Grid3DObject& operator-=(const Grid3DObject& rhs);
                const Grid3DObject operator-(const Grid3DObject& rhs) const;
 
                Grid3DObject& operator*=(const double& rhs);
                const Grid3DObject operator*(const double& rhs) const;
                Grid3DObject& operator*=(const Grid3DObject& rhs);
                const Grid3DObject operator*(const Grid3DObject& rhs) const;
 
                Grid3DObject& operator/=(const double& rhs);
                const Grid3DObject operator/(const double& rhs) const;
                Grid3DObject& operator/=(const Grid3DObject& rhs);
                const Grid3DObject operator/(const Grid3DObject& rhs) const;
 
                bool operator==(const Grid3DObject& in) const; 
                bool operator!=(const Grid3DObject& in) const; 
 
                Array3D<double> grid3D;
                std::vector<double> z; 
                Coords llcorner;
                double cellsize;
                bool z_is_absolute; 
 
 protected:
                void setValues(const double& cellsize, const Coords& i_llcorner);
 
                bool WGS84_to_grid(Coords point) const;
 
                bool grid_to_WGS84(Coords& point) const;
};
} //end namespace
 
#endif