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>

namespace cpt {


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

protected:

   typedef T Number;
   typedef geom::BBox<N, Number> BBox;
   typedef geom::RegularGrid<N, T> Lattice;
   typedef cpt::Grid<N, T> Grid;
   typedef cpt::BRep<N, T> BRep;

   typedef typename Grid::Point Point;
   typedef typename Grid::SizeList SizeList;
   typedef typename Grid::IndexList IndexList;
   typedef typename Grid::IndexList IndexedFace;
   typedef typename Grid::Index Index;
   typedef typename Grid::Range Range;

   //
   // 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&);

public:

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


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

   ~StateBase() {}

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


   std::size_t
   getNumberOfGrids() const {
      return _grids.size();
   }

   const Grid&
   getGrid(const std::size_t n) const {
      return _grids[n];
   }

   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* domainLowerData, const Number* domainUpperData,
                 const Number maximumDistance) {
      const Point domainLower = ext::copy_array<Point>(domainLowerData);
      const Point domainUpper = ext::copy_array<Point>(domainUpperData);
      setParameters(BBox(domainLower, domainUpper), maximumDistance);
   }


   void
   setParameters(const Number maximumDistance) {
      // The point at infinity.
      const Point Infinity =
         ext::filled_array<Point>(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 SizeList& extents, const BBox& domain);


   void
   setLattice(const int* extentsData, const Number* lowerData,
              const Number* upperData) {
      const SizeList extents = ext::copy_array<SizeList>(extentsData);
      const Point lower = ext::copy_array<Point>(lowerData);
      const Point upper = ext::copy_array<Point>(upperData);
      setLattice(extents, BBox(lower, upper));
   }


   void
   insertGrid(const SizeList& extents,
              const IndexList& bases,
              bool useGradientOfDistance,
              bool useClosestPoint,
              bool useClosestFace);


   void
   insertGrid(const SizeList& extents,
              const IndexList& bases,
              Number* distance,
              Number* gradientOfDistance,
              Number* closestPoint,
              int* closestFace);


   void
   insertGrid(const int* lowerBounds, const int* upperBounds, Number* distance,
              Number* gradientOfDistance, Number* closestPoint,
              int* closestFace) {
      const IndexList bases = ext::copy_array<IndexList>(lowerBounds);
      std::size_t extentsData[N];
      for (std::size_t i = 0; i < N; ++i)
         extentsData[i] = upperBounds[i] - lowerBounds[i] + 1;
      const SizeList extents = ext::copy_array<SizeList>(extentsData);
      insertGrid(extents, bases, distance, gradientOfDistance, closestPoint,
                 closestFace);
   }


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


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


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


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


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


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


   void
   floodFillAtBoundary(Number farAway);


   void
   floodFillDetermineSign(Number farAway);


   void
   floodFillUnsigned(Number farAway);


   bool
   areGridsValid();


   bool
   areGridsValidUnsigned();


   void
   setBRepWithNoClipping
   (const std::vector<std::tr1::array<Number, N> >& vertices,
    const std::vector<std::tr1::array<std::size_t, N> >& faces);

   void
   setBRepWithNoClipping(std::size_t numVertices, const Number* vertices,
                         std::size_t numFaces, const int* faces);


   void
   setBRep(const std::vector<std::tr1::array<Number, N> >& vertices,
           const std::vector<std::tr1::array<std::size_t, N> >& faces);

   void
   setBRep(std::size_t numVertices, const Number* vertices,
           std::size_t numFaces, const int* faces);

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


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

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


protected:

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


};

} // namespace cpt

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

#endif

---