StructuredGrid.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_StructuredGrid_h__)
#define __geom_StructuredGrid_h__

#if defined(DEBUG_geom) && !defined(DEBUG_StructuredGrid)
#define DEBUG_StructuredGrid
#endif

#include "../../defs.h"
#include "../../kernel/BBox.h"
#include "../../kernel/content.h"

#include "../../../ads/array/Array.h"

#include <iosfwd>

#include <cassert>

BEGIN_NAMESPACE_GEOM


template<int N, int M, typename T = double>
class StructuredGrid {
public:

  //
  // Public types.
  //

  typedef T Number;
  typedef ads::FixedArray<M,Number> Point;
  typedef ads::Array<N,Point> Array;
  typedef BBox<N,Number> BBox;

  //
  // Types that make this a container.
  //

  typedef typename Array::value_type Value;

  typedef typename Array::pointer Pointer;
  typedef typename Array::const_pointer ConstPointer;

  typedef typename Array::iterator Iterator;
  typedef typename Array::const_iterator ConstIterator;

  typedef typename Array::reference Reference;
  typedef typename Array::const_reference ConstReference;

  typedef typename Array::size_type SizeType;
  typedef typename Array::difference_type DifferenceType;

  typedef typename Array::index_type Index;

private:

  //
  // Data
  //

  Array _grid;

public:

  //--------------------------------------------------------------------------

  StructuredGrid() :
    _grid()
  {}


  template<bool A>
  StructuredGrid(const ads::Array<N,Point,A>& grid) :
    _grid(grid)
  {}


  StructuredGrid(const Index& extents) :
    _grid(extents)
  {}

  StructuredGrid(const StructuredGrid& other) :
    _grid(other._grid)
  {}

  StructuredGrid&
  operator=(const StructuredGrid& other) {
    if (this != &other) {
      _grid = other._grid;
    }
    return *this;
  }

  ~StructuredGrid()
  {}

  //--------------------------------------------------------------------------

  BBox
  computeBBox() const {
    BBox bbox;
    bbox.bound(_grid.begin(), _grid.end()); 
    return bbox;
  }

  //--------------------------------------------------------------------------

  static
  int
  getSpaceDimension() {
    return N;
  }

  static
  int
  getGridDimension() {
    return M;
  }

  const Index&
  getExtents() const {
    return _grid.extents();
  }

  SizeType
  getSize() const {
    return _grid.size();
  }

  ConstIterator
  getBeginning() const { 
    return _grid.begin();
  }

  ConstIterator
  getEnd() const { 
    return _grid.end();
  }

  const Array&
  getGrid() const {
    return _grid;
  }

  ConstReference
  operator()(const Index& mi) const {
    return _grid(mi);
  }

  ConstReference
  operator()(const int i, const int j) const {
    return _grid(i, j);
  }

  ConstReference
  operator()(const int i, const int j, const int k) const {
    return _grid(i, j, k);
  }

  //--------------------------------------------------------------------------

  Iterator
  getBeginning() { 
    return _grid.begin();
  }

  Iterator
  getEnd() { 
    return _grid.end();
  }

  // CONTINUE
#if 0
  Array&
  grid() {
    return _grid;
  }
#endif

  Reference
  operator()(const Index& mi) {
    return _grid(mi);
  }

  ConstReference
  operator()(const int i, const int j) {
    return _grid(i, j);
  }

  ConstReference
  operator()(const int i, const int j, const int k) {
    return _grid(i, j, k);
  }

  //--------------------------------------------------------------------------

  bool
  isEqualTo(const StructuredGrid& x) const {
    return _grid = x._grid;
  }

  //--------------------------------------------------------------------------

  void
  put(std::ostream& out) const {
    out << _grid.extents() << '\n';
    _grid.write_elements_ascii(out);
  }

  void
  get(std::istream& in) {
    Index extents;
    in >> extents;
    _grid.resize(extents);
    _grid.read_elements_ascii(in);
  }

  void
  writeIndexedSimplexSet(std::ostream& out) const;

};


//
// File I/O
//



template<int N, int M, typename T>
inline
std::ostream& 
operator<<(std::ostream& out, const StructuredGrid<N,M,T>& x) {
  x.put(out);
  return out;
}



template<int N, int M, typename T>
inline
std::istream& 
operator>>(std::istream& in, StructuredGrid<N,M,T>& x) {
  x.get(in);
  return in;
}


//
// Equality tests
//



template<int N, int M, typename T>
inline
bool 
operator==(const StructuredGrid<N,M,T>& a, const StructuredGrid<N,M,T>& b) {
  return a.isEqualTo(b);
}



template<int N, int M, typename T>
inline
bool 
operator!=(const StructuredGrid<N,M,T>& a, const StructuredGrid<N,M,T>& b) {
  return !(a == b);
}


END_NAMESPACE_GEOM

#define __geom_StructuredGrid_ipp__
#include "StructuredGrid.ipp"
#undef __geom_StructuredGrid_ipp__

#endif

---