StateBase.h

// -*- C++ -*-

#if !defined(__cpt_StateBase_h__)
#define __cpt_StateBase_h__

// Local
#include "Grid.h"
#include "BRep.h"

#include "../geom/mesh/iss/distance.h"

#include <iostream>

#include <cmath>

BEGIN_NAMESPACE_CPT


template<int N, typename T = double>
class StateBase {
  //
  // Protected types.
  //

protected:

  typedef T Number;
  typedef ads::FixedArray<N,Number> Point;
  typedef ads::FixedArray<N,int> IndexedFace;
  typedef ads::FixedArray<N,int> Index;
  typedef ads::IndexRange<N,int> Range;
  typedef geom::BBox<N,Number> BBox;
  typedef geom::RegularGrid<N,T> Lattice;
  typedef cpt::Grid<N,T> Grid;
  typedef cpt::BRep<N,T> BRep;

  //
  // Member data.
  //

protected:

  bool _hasBRepBeenSet;
  bool _hasCptBeenComputed;

  BBox _domain;
  Number _maximumDistance;
  Lattice _lattice;
  std::vector<Grid> _grids;
  BRep _brep;

  //
  // Not implemented.
  //

private:

  StateBase(const StateBase&);

  StateBase&
  operator=(const StateBase&);

  // CONTINUE: Modified to compile with gcc 3.3.  It cannot use insertGrid
  // in the derived class when it is protected here.
  //protected:
public:

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


  StateBase() :
    _hasBRepBeenSet(false),
    _hasCptBeenComputed(false),
    _domain(),
    _maximumDistance(-1),
    _lattice(),
    _grids(),
    _brep()
  {}

  ~StateBase()
  {}

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


  int
  getNumberOfGrids() const {
    return int(_grids.size());
  }

  bool
  hasBRepBeenSet() const {
    return _hasBRepBeenSet;
  }

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

  Number
  getMaximumDistance() const {
    return _maximumDistance;
  }

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


  // CONTINUE: The max distance should be specified on a per level basis.

  void 
  setParameters(const BBox& domain, Number maximumDistance);


  void 
  setParameters(const Number* domain, const Number maximumDistance) {
    setParameters(BBox(domain), maximumDistance);
  }


  void 
  setParameters(const Number maximumDistance) {
    // The point at infinity.
    const Point Infinity(std::numeric_limits<Number>::max());
    // Call setParameters() with all of space as the domain.
    setParameters(BBox(-Infinity, Infinity), maximumDistance);
  }

  // CONTINUE Make sure setLattice is called before adding grids.
  // CONTINUE enable multiple levels.  Add documentation.

  void 
  setLattice(const Index& extents, const BBox& domain);


  void 
  setLattice(const int* extents, const Number* domain) {
    setLattice(Index(extents), BBox(domain));
  }


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


  void 
  insertGrid(const int* indexLowerBounds,
             const int* indexUpperBounds,
             Number* distance,
             Number* gradientOfDistance,
             Number* closestPoint,
             int* closestFace);


  void
  clearGrids() {
    _grids.clear();
  }


  std::pair<int,int>
  computeClosestPointTransformUsingBBox();


  std::pair<int,int>
  computeClosestPointTransformUsingBruteForce();


  std::pair<int,int>
  computeClosestPointTransformUsingTree();


  std::pair<int,int>
  computeClosestPointTransformUnsignedUsingBBox();


  std::pair<int,int>
  computeClosestPointTransformUnsignedUsingBruteForce();


  void
  floodFillAtBoundary(Number farAway);


  void
  floodFillDetermineSign(Number farAway);


  void
  floodFillUnsigned(Number farAway);


  bool 
  areGridsValid();


  bool 
  areGridsValidUnsigned();


  void 
  setBRepWithNoClipping(int verticesSize,
                        const void* vertices,
                        int facesSize,
                        const void* faces);


  void 
  setBRep(int verticesSize,
          const void* vertices,
          int facesSize,
          const void* faces);

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


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

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


protected:

  void
  initializeGrids() {
    for (int n = 0; n != getNumberOfGrids(); ++n) {
      _grids[n].initialize();
    }
  }


};

END_NAMESPACE_CPT

#define __cpt_StateBase_ipp__
#include "StateBase.ipp"
#undef __cpt_StateBase_ipp__

#endif

---