PointsOnManifoldN11.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_PointsOnManifoldN11_h__)
#define __geom_PointsOnManifoldN11_h__


BEGIN_NAMESPACE_GEOM



template<int _N, typename T>
class PointsOnManifold<_N,1,1,T> {
  //
  // Public enumerations.
  //

public:

  enum {N = _N, M = 1, SD = 1};

  //
  // Private enumerations.
  //

  // CONTINUE: With the Intel compiler, private members are not accessible in
  // nested classes.
#ifdef __INTEL_COMPILER
public:
#else
private:
#endif

  enum Feature {NullFeature, CornerFeature, SurfaceFeature};

  //
  // Nested classes.
  //

private:
  
  class FaceHandle {
  private:

    Feature _feature;
    int _index;

  public:

    //
    // Constructors, etc.
    //

    FaceHandle() :
      _feature(NullFeature),
      _index(-1)
    {}

    FaceHandle(const FaceHandle& other) :
      _feature(other._feature),
      _index(other._index)
    {}

    FaceHandle&
    operator=(const FaceHandle& other) {
      // Avoid assignment to self.
      if (this != &other) {
        _feature = other._feature;
        _index = other._index;
      }
      // Return a reference to this so assignments can chain.
      return *this;
    }
    
    FaceHandle(const Feature feature, const int index) :
      _feature(feature),
      _index(index)
    {}

    ~FaceHandle()
    {}

    //
    // Accessors.
    //

    Feature
    getFeature() const {
      return _feature;
    }

    int
    getIndex() const {
      return _index;
    }

    //
    // Manipulators
    //

    void
    setFeature(const Feature feature) {
      _feature = feature;
    }

    void
    setIndex(const int index) {
      _index = index;
    }

    void
    setToNull() {
      _feature = NullFeature;
      _index = -1;
    }
  };

  //
  // Private types.
  //

private:

  typedef IndSimpSetIncAdj<N,M,true,T> SurfaceManifold;
  typedef int SizeType;
  typedef std::map<int,FaceHandle> PointMap;
  typedef typename PointMap::value_type Point;

  //
  // Public types.
  //

public:

  typedef T Number;
  typedef typename SurfaceManifold::Vertex Vertex;

  //
  // Member data.
  //

private:
  
  SurfaceManifold _surfaceManifold;
  ads::Array<1,int> _cornerIndices;
  ads::Array<1,Feature> _vertexFeatures;
  PointMap _points;
  ISS_SimplexQuery<SurfaceManifold> _simplexQuery;
  Number _maxCornerDistance;

  mutable int _cachedIdentifier;
  mutable FaceHandle _cachedFace;

  //
  // Not implemented.
  //

private:

  PointsOnManifold();

  PointsOnManifold(const PointsOnManifold&);

  PointsOnManifold& 
  operator=(const PointsOnManifold&);

public:

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


  template<bool A, typename V, typename IS, typename IntInIter>
  PointsOnManifold(const IndSimpSet<N,M,A,T,V,IS>& iss,
                   IntInIter cornersBegin, IntInIter cornersEnd);


  template<bool A, typename V, typename IS>
  PointsOnManifold(const IndSimpSet<N,M,A,T,V,IS>& iss,
                   Number maxAngleDeviation = -1);

  ~PointsOnManifold()
  {}

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

  SizeType
  countNumberOfPoints() const {
    return SizeType(_points.size());
  }

  void
  countNumberOfPointsOnFeatures(SizeType* surfaceCount, SizeType* cornerCount)
    const;

  SizeType
  countNumberOfSurfacePoints() const;

  SizeType
  countNumberOfCornerPoints() const;

  bool
  isVertexASurfaceFeature(const int n) const {
    return _vertexFeatures[n] == SurfaceFeature;
  }

  bool
  isVertexACornerFeature(const int n) const {
    return _vertexFeatures[n] == CornerFeature;
  }

  bool
  isOnSurface(const int identifier) const {
    return isOnFeature(identifier, SurfaceFeature);
  }
  
  bool
  isOnCorner(const int identifier) const {
    return isOnFeature(identifier, CornerFeature);
  }

  bool
  hasPoint(const int identifier) const {
    return _points.count(identifier) == 1;
  }


  int
  getSimplexIndex(const int identifier) const;
  

  int
  getVertexIndex(const int identifier) const;

  Number
  getMaxCornerDistance() const {
    return _maxCornerDistance;
  }

  template<typename IntInsertIterator>
  void
  getNeighborhood(const int identifier, IntInsertIterator iter) const {
    // If the vertex is a corner feature.
    if (isOnCorner(identifier)) {
      getCornerNeighborhood(getVertexIndex(identifier), iter);
    }
    // Otherwise, it is a surface feature.
    else {
      getSurfaceNeighborhood(getSimplexIndex(identifier), iter);
    }
  }

  const Vertex&
  getSurfaceSimplexVertex(const int simplexIndex, const int m) const {
    return _surfaceManifold.getSimplexVertex(simplexIndex, m);
  }

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


  void
  setMaxCornerDistance(const Number x) {
    _maxCornerDistance = x;
  }

  void
  changeIdentifier(int existingIdentifier, int newIdentifier);


  Vertex
  changeLocation(int pointIdentifier, const Vertex& newLocation);

  void
  changeSurfaceSimplex(int pointIdentifier, int simplexIndex);

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

  void
  insertAtVertex(int pointIdentifier, int vertexIndex);


  void
  insertAtVertices();


  Vertex
  insertNearPoint(int newPointID, const Vertex& position, int existingPointID);


  Vertex
  insertNearPoints(int newPointID, const Vertex& position, 
                   int existingPointID1, int existingPointID2);

  Vertex
  insertOnASurface(int pointIdentifier, const Vertex& position);


  Vertex
  insert(int pointIdentifier, const Vertex& position);


  template<typename PointInputIterator, typename PointOutputIterator>
  void
  insert(PointInputIterator locationsBegin, PointInputIterator locationsEnd,
         PointOutputIterator closestPoints);


  template<bool A, typename V, typename IS>
  void
  insertBoundaryVertices(IndSimpSetIncAdj<N,M+1,A,T,V,IS>* mesh);
  

  template<template<class> class Node,
           template<class> class Cell,
           template<class,class> class Container>
  void
  insertBoundaryVertices(SimpMeshRed<N,M+1,T,Node,Cell,Container>* mesh);
  
  void
  erase(int pointIdentifier);

  void
  clearPoints() {
    _points.clear();
  }

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


  Vertex
  computeClosestPoint(int pointIdentifier, const Vertex& position) const;

  void
  updatePoint();

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

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


  //--------------------------------------------------------------------------
  // Private member functions.
  //

private:


  Vertex
  insertInSimplex(int pointIdentifier, const Vertex& position, 
                  int simplexIndex);


  int
  findCornerVertex(const Vertex& position) const;


  template<typename IntInputIterator>
  Vertex
  computeClosestPointInSimplices(IntInputIterator indicesBegin, 
                                 IntInputIterator indicesEnd, 
                                 const Vertex& position) const;

  Number
  computeClosestPointInSimplex(int simplexIndex, const Vertex& x, 
                               Vertex* closestPoint) const;

  Vertex
  computeClosestPointInSimplex(int simplexIndex, const Vertex& x) const;

  bool
  isOnFeature(int identifier, Feature feature) const;

  bool
  isValid(const FaceHandle& face) const;
  
  template<typename IntInsertIterator>
  void
  getNeighborhood(const FaceHandle& face, IntInsertIterator iter) const;


  template<typename IntInsertIterator>
  void
  getSurfaceNeighborhood(const int simplexIndex, IntInsertIterator iter) const;

  template<typename IntInsertIterator>
  void
  getCornerNeighborhood(const int vertexIndex, IntInsertIterator iter) const;

  void
  determineCorners(Number maxAngleDeviation);

  void
  determineBoundaryCorners();
  
  void
  recordCorners();
};

END_NAMESPACE_GEOM

#define __geom_PointsOnManifoldN11_ipp__
#include "PointsOnManifoldN11.ipp"
#undef __geom_PointsOnManifoldN11_ipp__

#endif

---