PointsOnManifold321.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_PointsOnManifold321_h__)
#define __geom_PointsOnManifold321_h__


BEGIN_NAMESPACE_GEOM

// CONTINUE:  I need the ability to have corner features defined only by
// the solid angle and at the same time have edge features that fall below
// that solid angle.  Do this by defining a vertex with small solid angle
// and two incident edges as on edge feature.

// CONTINUE: Replace the term surface feature with smooth feature.

// CONTINUE: Consider a node with two incident edge features in which
// the angle between these two edges has a large deviation from pi.  In
// this case the node should be a corner feature.  Add this functionality
// to the code and the documentation.


template<typename T>
class PointsOnManifold<3,2,1,T> {
  //
  // Public enumerations.
  //

public:

  enum {N = 3, M = 2, 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, EdgeFeature, 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 typename SurfaceManifold::Face SurfaceEdge;
  typedef int SizeType;
  typedef std::map<int,FaceHandle> PointMap;
  typedef ads::OrderedPair<int> RegisteredEdge;
  typedef std::set<RegisteredEdge> EdgeSet;
  typedef typename PointMap::value_type Point;

  //
  // Public types.
  //

public:

  typedef T Number;
  typedef typename SurfaceManifold::Vertex Vertex;
  // CONTINUE: I could wrap the vertex array from the surface to save memory.
  typedef IndSimpSetIncAdj<N,M-1,true,T> EdgeManifold;

  //
  // Member data.
  //

private:
  
  SurfaceManifold _surfaceManifold;

  ads::Array<2,bool> _isAnEdge;
  EdgeManifold _edgeManifold;
  ads::Array<1,int> _cornerIndices;
  ads::Array<1,Feature> _vertexFeatures;
  PointMap _points;
  EdgeSet _edges;
  ISS_SimplexQuery<SurfaceManifold> _surfaceQuery;
  ISS_SimplexQuery<EdgeManifold> _edgeQuery;
  Number _maxCornerDistance;
  Number _maxEdgeDistance;

  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 EdgeInIter,
           typename IntInIter>
  PointsOnManifold(const IndSimpSet<N,M,A,T,V,IS>& iss,
                   EdgeInIter edgesBegin, EdgeInIter edgesEnd,
                   IntInIter cornersBegin, IntInIter cornersEnd);


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

  ~PointsOnManifold()
  {}

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

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

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

  SizeType
  countNumberOfSurfacePoints() const;

  SizeType
  countNumberOfEdgePoints() const;

  SizeType
  countNumberOfCornerPoints() const;

  SizeType
  countNumberOfEdges() const {
    return _edges.size();
  }

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

  bool
  isVertexAnEdgeFeature(const int n) const {
    return _vertexFeatures[n] == EdgeFeature;
  }

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

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

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

  bool
  hasEdge(int pointId1, int pointId2) const;


  int
  getSurfaceSimplexIndex(const int identifier) const;
  

  int
  getEdgeSimplexIndex(const int identifier) const;
  

  int
  getVertexIndex(const int identifier) const;

  Number
  getMaxCornerDistance() const {
    return _maxCornerDistance;
  }

  Number
  getMaxEdgeDistance() const {
    return _maxEdgeDistance;
  }

  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);
    }
    // If the vertex is an edge feature.
    else if (isOnEdge(identifier)) {
      getEdgeNeighborhood(getEdgeSimplexIndex(identifier), iter);
    }
    // Otherwise, it is a surface feature.
    else {
      getSurfaceNeighborhood(getSurfaceSimplexIndex(identifier), iter);
    }
  }

  const Vertex&
  getEdgeSimplexVertex(const int simplexIndex, const int m) const {
    // No need to test the validity of the parameters.  This is done in the
    // following call.
    return _edgeManifold.getSimplexVertex(simplexIndex, m);
  }

  const Vertex&
  getSurfaceSimplexVertex(const int simplexIndex, const int m) const {
    // No need to test the validity of the parameters.  This is done in the
    // following call.
    return _surfaceManifold.getSimplexVertex(simplexIndex, m);
  }

  const EdgeManifold&
  getEdgeManifold() const {
    return _edgeManifold;
  }

  const ads::Array<1,int>&
  getCornerIndices() const {
    return _cornerIndices;
  }


  template<bool A33, typename V33, typename IS33, typename V31, typename IS31>
  void
  getEdgesOnEdgeFeatures(const IndSimpSet<3,3,A33,Number,V33,IS33>& solidMesh,
                         IndSimpSet<3,1,true,Number,V31,IS31>* edgeMesh) const;

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


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


  void
  setMaxEdgeDistance(const Number x) {
    _maxEdgeDistance = x;
  }

  void
  changeIdentifier(int existingIdentifier, int newIdentifier);


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

  void
  changeSurfaceSimplex(int pointIdentifier, int simplexIndex);

  void
  changeEdgeSimplex(int pointIdentifier, int simplexIndex);

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

  void
  insertAtVertex(int pointIdentifier, int vertexIndex);


  void
  insertAtVertices();


  void
  insertAtVerticesAndEdges();

// CONTINUE: Implement this or something like it.
#if 0


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

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


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

  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
  insertBoundaryVerticesAndEdges(IndSimpSetIncAdj<N,M+1,A,T,V,IS>* mesh,
                                 Number maxDihedralAngleDeviation = -1);


  template<template<class> class Node,
           template<class> class Cell,
           template<class,class> class Container>
  void
  insertBoundaryVerticesAndEdges
  (SimpMeshRed<N,M+1,T,Node,Cell,Container>* mesh,
   Number maxDihedralAngleDeviation = -1);


  template<template<class> class Node,
           template<class> class Cell,
           template<class,class> class Container>
  void
  insertVerticesAndEdges(SimpMeshRed<N,M,T,Node,Cell,Container>* mesh,
                         Number maxDihedralAngleDeviation = -1);

  void
  erase(int pointIdentifier);

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

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

  void
  insert(int pointId1, int pointId2);


  void
  insertAtEdges();

  void
  erase(int pointId1, int pointId2);

  void
  clearEdges() {
    _edges.clear();
  }


  void
  splitEdge(int source, int target, int middle);

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


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

  void
  updatePoint();

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

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


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

private:


  template<typename EdgeInIter, typename IntInIter>
  void
  buildEdgesAndCorners(EdgeInIter edgesBegin, EdgeInIter edgesEnd,
                       IntInIter cornersBegin, IntInIter cornersEnd);


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


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


  int
  findCornerVertex(const Vertex& position) const;


  int
  findEdgeSimplex(const Vertex& position) const;


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


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

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

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

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

  Vertex
  computeClosestPointInEdgeSimplex(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
  getEdgeNeighborhood(const int simplexIndex, IntInsertIterator iter) const;

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

END_NAMESPACE_GEOM

#define __geom_PointsOnManifold321_ipp__
#include "PointsOnManifold321.ipp"
#undef __geom_PointsOnManifold321_ipp__

#endif

---