GridBase.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__cpt_GridBase_h__)
#define __cpt_GridBase_h__

// Local
#include "defs.h"

// Algorithms and data structures package.
#include "../ads/array/Array.h"
#include "../ads/array/IndexIterator.h"

// Computational geometry package.
#include "../geom/grid/RegularGrid.h"

#include <iostream>
#include <vector>

BEGIN_NAMESPACE_CPT


template<int N, typename T>
class GridBase {
  //
  // Private types.
  //

private:

  typedef ads::Array<N,int> ArrayInt;

  //
  // Protected types.
  //

protected:

  typedef T Number;
  typedef ads::FixedArray<N,Number> Point;
  typedef typename ArrayInt::index_type Index;
  typedef typename ArrayInt::range_type Range;
  typedef geom::RegularGrid<N,Number> Lattice;
  
  //
  // Data.
  //

private:

  ads::Array<N,Number,false> _distance;

  ads::Array<N,Point,false> _gradientOfDistance;

  ads::Array<N,Point,false> _closestPoint;

  ads::Array<N,int,false> _closestFace;

protected:

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


  GridBase() : 
    _distance(),
    _gradientOfDistance(),
    _closestPoint(),
    _closestFace()
  {}

  GridBase(const GridBase& other) :
    _distance(other._distance),
    _gradientOfDistance(other._gradientOfDistance),
    _closestPoint(other._closestPoint),
    _closestFace(other._closestFace)
  {}

  template<bool A1, bool A2, bool A3, bool A4>
  GridBase(ads::Array<N,Number,A1>* distance,
           ads::Array<N,Point,A2>* gradientOfDistance, 
           ads::Array<N,Point,A3>* closestPoint,
           ads::Array<N,int,A4>* closestFace);

  ~GridBase()
  {}

  GridBase& 
  operator=(const GridBase& other);
  

public:

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


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

  const Range&
  getRanges() const { 
    return _distance.ranges();
  }

  bool
  isEmpty() const {
    return _distance.empty();
  }

  const ads::Array<N,Number,false>& 
  getDistance() const { 
    return _distance; 
  }

  const ads::Array<N,Point,false>& 
  getGradientOfDistance() const { 
    return _gradientOfDistance; 
  }

  const ads::Array<N,Point,false>& 
  getClosestPoint() const { 
    return _closestPoint; 
  }

  const ads::Array<N,int,false>& 
  getClosestFace() const { 
    return _closestFace; 
  }

  bool 
  isGradientOfDistanceBeingComputed() const { 
    return ! _gradientOfDistance.empty(); 
  }

  bool 
  isClosestPointBeingComputed() const { 
    return ! _closestPoint.empty(); 
  }

  bool 
  isClosestFaceBeingComputed() const { 
    return ! _closestFace.empty(); 
  }

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


  ads::Array<N,Number,false>& 
  getDistance() { 
    return _distance; 
  }

  ads::Array<N,Point,false>& 
  getGradientOfDistance() { 
    return _gradientOfDistance; 
  }

  ads::Array<N,Point,false>& 
  getClosestPoint() { 
    return _closestPoint; 
  }

  ads::Array<N,int,false>& 
  getClosestFace() { 
    return _closestFace; 
  }

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



  template<class Component>
  std::pair<int,int>
  computeClosestPointTransform(const std::vector<Index>& indices,
                               const std::vector<Point>& positions,
                               const Component& component,
                               Number maximumDistance);

  template<class Component>
  std::pair<int,int>
  computeClosestPointTransformUnsigned(const std::vector<Index>& indices,
                                       const std::vector<Point>& positions,
                                       const Component& component,
                                       Number maximumDistance);


  template<class Component>
  std::pair<int,int>
  computeClosestPointTransform(const Lattice& lattice,
                               const Range& indexRangeInLattice,
                               const Component& component,
                               Number maximumDistance);


  template<class Component>
  std::pair<int,int>
  computeClosestPointTransformUnsigned(const Lattice& lattice,
                                       const Range& indexRangeInLattice,
                                       const Component& component,
                                       Number maximumDistance);


  void 
  initialize();


  bool 
  floodFillUnsigned(const Number farAway);

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


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

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

  int
  countKnownDistances(const Number maximumDistance) const;

  void 
  computeMinimumAndMaximumDistances(const Number maximumDistance, 
                                    Number* minimum, Number* maximum) const;

};

END_NAMESPACE_CPT

//
// Equality operators
//


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


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

#define __GridBase_ipp__
#include "GridBase.ipp"
#undef __GridBase_ipp__

#endif

---