raster.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program 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.
 */
 
#ifndef __H__UG_raster
#define __H__UG_raster
 
#include "common/math/ugmath_types.h"
 
namespace ug{
 
 
template <class T, int TDIM>
class Raster{
  public:
    class MultiIndex {
      public:
        MultiIndex();
        MultiIndex(size_t i);
        int dim () const;
        void    set (size_t i);
        size_t&   operator[] (int d);
        size_t    operator[] (int d) const;
 
        friend std::ostream& operator << (std::ostream& o, const MultiIndex& mi)
        {
          o << "(";
          for(size_t d = 0; d < TDIM; ++d){
            o << mi[d];
            if(d + 1 < TDIM)
              o << ", ";
          }
          o << ")";
          return o;
        }
 
      private:
        size_t  m_ind[TDIM];
    };
 
    class Coordinate {
      public:
        Coordinate();
        Coordinate(number c);
        Coordinate(const MathVector<TDIM, number>& v);
 
        int dim () const;
        void    set (number c);
        number&   operator[] (int d);
        number    operator[] (int d) const;
        Coordinate& operator+= (const Coordinate& c);
        Coordinate& operator-= (const Coordinate& c);
        Coordinate& operator*= (number s);
        
        friend std::ostream& operator << (std::ostream& o, const Coordinate& coord)
        {
          o << "(";
          for(size_t d = 0; d < TDIM; ++d){
            o << coord[d];
            if(d + 1 < TDIM)
              o << ", ";
          }
          o << ")";
          return o;
        }
 
      private:
        number  m_coord[TDIM];
    };
 
 
    Raster ();
 
    Raster (const Raster& raster);
 
 
    Raster (const MultiIndex& numNodes);
    
 
    Raster (const MultiIndex& numNodes,
        const Coordinate& extension,
        const Coordinate& minCorner = Coordinate(0));
 
    ~Raster ();
 
    Raster& operator= (const Raster& raster);
 
    void load_from_asc (const char* filename);
    void save_to_asc (const char* filename) const;
 
    int dim () const;
 
 
    void set_num_nodes (int dim, size_t num);
    void set_num_nodes (const MultiIndex& mi);
 
    size_t num_nodes_total () const;
    size_t num_nodes (int dim) const;
    const MultiIndex& num_nodes () const;
 
    void create ();
 
    T& node_value (const MultiIndex& mi);
 
    T node_value (const MultiIndex& mi) const;
 
 
    void set_min_corner (int dim, number coord);
    void set_min_corner (const Coordinate& coord);
    const Coordinate& min_corner () const;
 
    number min_corner (int dim) const;
 
 
    void set_extension (int dim, number ext);
    void set_extension (const Coordinate& coord);
    const Coordinate& extension () const;
 
    number extension (int dim) const;
 
    void set_no_data_value(T val);
 
    T no_data_value() const;
 
    T interpolate (const Coordinate& coord, int order) const;
 
    void blur(T alpha, size_t iterations);
 
 
 
    template <class TKernel>
    typename TKernel::result_t
    run_on_all();
 
 
    template <class TKernel>
    void run_on_all(TKernel& kernel);
 
 
 
    template <class TKernel>
    typename TKernel::result_t
    run_on_nbrs(const MultiIndex& center);
 
 
    template <class TKernel>
    void run_on_nbrs(const MultiIndex& center, TKernel& kernel);
 
  //  Convenience methods for easy scripting below.
 
 
    void select_node (int dim, size_t index);
    void select_node (const MultiIndex& mi);
    void set_selected_node_value (T val);
 
    T selected_node_value () const;
 
 
    void set_cursor (int dim, number coord);
    void set_cursor (const Coordinate& coord);
    T interpolate_at_cursor (int order) const;
 
  private:
    template <class TKernel>
    void run_on_all(const MultiIndex& start, TKernel& kernel, int curDim);
 
    template <class TKernel>
    void run_on_nbrs(const MultiIndex& center, TKernel& kernel, int curDim);
 
    size_t data_index (
          const MultiIndex& mi,
          int curDim = TDIM - 1,
          size_t curVal = 0) const;
 
    void update_num_nodes_total();
    void update_cell_extension ();
    void update_cell_extension (int dim);
 
    T interpolate_linear (
        const MultiIndex& minNodeInd,
        Coordinate& localCoord,
        int curDim = TDIM) const;
 
    T*      m_data;
    MultiIndex  m_numNodes;
    MultiIndex  m_selNode;
    Coordinate  m_minCorner;
    Coordinate  m_extension;
    Coordinate  m_cellExtension;
    Coordinate  m_cursor;
    size_t    m_numNodesTotal;
    T     m_noDataValue;
};
 
}// end of namespace
 
// include implementation
#include "raster_impl.hpp"
 
#endif  //__H__UG_raster