RegularGrid.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_RegularGrid_h__)
#define __geom_RegularGrid_h__

#include <iosfwd>

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

#include <limits>

BEGIN_NAMESPACE_GEOM


template<int N, typename T = double>
class RegularGrid {
  //
  // Public types.
  //

public:
      
  typedef T Number;
  typedef int SizeType;
  typedef ads::FixedArray<N,SizeType> Index;
  typedef ads::FixedArray<N,Number> Point;
  typedef BBox<N,T> BBox;

  //
  // Data
  //

private:

  Index _extents;

  BBox _domain;

  Point _length;

  Point _delta;

  Number _indexEpsilon;

  Number _cartesianEpsilon;


public:

  //--------------------------------------------------------------------------
  // @{

  RegularGrid() :
    _extents(),
    _domain(),
    _length(),
    _delta(),
    _indexEpsilon(),
    _cartesianEpsilon()
  {}


  RegularGrid(const Index& extents, const BBox& domain);

  RegularGrid(const RegularGrid& other);

  RegularGrid& 
  operator=(const RegularGrid& other);

  ~RegularGrid() 
  {}

  // @}
  //--------------------------------------------------------------------------
  // @{

  const Index&
  getExtents() const { 
    return _extents; 
  }

  const Point&
  getDelta() const { 
    return _delta; 
  }

  const BBox&
  getDomain() const { 
    return _domain; 
  }

  Number 
  getIndexEpsilon() const { 
    return _indexEpsilon; 
  }

  Number 
  getCartesianEpsilon() const { 
    return _cartesianEpsilon; 
  }
  
  // @}
  //--------------------------------------------------------------------------
  // @{

  void 
  convertLocationToIndex(Point* p) const { 
    *p = (*p - _domain.getLowerCorner()) / _delta; 
  }

  void 
  convertIndexToLocation(Point* p) const { 
    *p = _domain.getLowerCorner() + *p *  _delta; 
  }

  void 
  convertVectorToIndex(Point* p) const { 
    *p /= _delta; 
  }

  void 
  convertBBoxLocationsToIndices(BBox* box) const { 
    Point p = box->getLowerCorner();
    convertLocationToIndex(&p);
    box->setLowerCorner(p);
    p = box->getUpperCorner();
    convertLocationToIndex(&p);
    box->setUpperCorner(p);
  }

  void 
  convertBBoxIndicesToLocations(BBox* box) const { 
    Point p = box->getLowerCorner();
    convertIndexToLocation(&p);
    box->setLowerCorner(p);
    p = box->getUpperCorner();
    convertIndexToLocation(&p);
    box->setUpperCorner(p);
  }

  void 
  convertBBoxIndicesToLocations(const geom::BBox<N,int>& indexBox,
                                BBox* cartesianBox) const { 
    Point p = indexBox.getLowerCorner();
    convertIndexToLocation(&p);
    cartesianBox->setLowerCorner(p);
    p = indexBox.getUpperCorner();
    convertIndexToLocation(&p);
    cartesianBox->setUpperCorner(p);
  }

  template<typename OutputIterator>
  void 
  convertLocationsToIndices(OutputIterator begin, OutputIterator end) const {
    for (; begin != end; ++begin) {
      convertLocationToIndex(&*begin);
    }
  }

  template<typename OutputIterator>
  void 
  convertIndicesToLocations(OutputIterator begin, OutputIterator end) const { 
    for (; begin != end; ++begin) {
      convertIndexToLocation(&*begin);
    }
  }

  template<typename OutputIterator>
  void 
  convertVectorsToIndices(OutputIterator begin, OutputIterator end) const { 
    for (; begin != end; ++begin) {
      convertVectorToIndex(&*begin);
    }
  }

  // @}
};


//
// Equality operators.
//



template<int N, typename T>
bool 
operator==(const RegularGrid<N,T>& a, const RegularGrid<N,T>& b);



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


//
// File I/O
//



template<int N, typename T>
std::ostream& 
operator<<(std::ostream& out, const RegularGrid<N,T>& grid);



template<int N, typename T>
std::istream& 
operator>>(std::istream& in, RegularGrid<N,T>& grid);


END_NAMESPACE_GEOM

#define __geom_RegularGrid_ipp__
#include "RegularGrid.ipp"
#undef __geom_RegularGrid_ipp__

#endif

---