Edge.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__cpt_Edge_h__)
#define __cpt_Edge_h__

#include "defs.h"

#include "../ads/array/FixedArray.h"

#include "../geom/grid/RegularGrid.h"
#include "../geom/kernel/BBox.h"
#include "../geom/kernel/SegmentMath.h"
#include "../geom/polytope/IndexedEdgePolyhedron.h"

#include <vector>

#include <cmath>

BEGIN_NAMESPACE_CPT

template<int N, typename T = double>
class Edge;

template<typename T>
class Edge<3,T> {
public:
        
  //
  // Public types.
  //
        
  typedef T Number;
        
  typedef ads::FixedArray<3,T> Point;
        
  typedef geom::BBox<3,Number> BBox;
        
  typedef geom::RegularGrid<3,Number> Grid;
        
  typedef geom::IndexedEdgePolyhedron<Number> Polyhedron;

private:
                
  //
  // Private types.
  //
                
  typedef geom::SegmentMath<3,Number> Segment;
        
private:
                
  //
  // Data
  //
                
  Segment _segment;
        
  Point _leftFaceNormal, _rightFaceNormal;
        

  Point _leftSideNormal, _rightSideNormal;
        
  int _adjacentFaceIndex;
        
  int _signOfDistance;
        
  Number _epsilon;
        
public:
                
  //-------------------------------------------------------------------------

                
  Edge() :
    _segment(),
    _leftFaceNormal(),
    _rightFaceNormal(),
    _leftSideNormal(),
    _rightSideNormal(),
    _adjacentFaceIndex(),
    _signOfDistance(),
    _epsilon()
  {}
        
  Edge(const Point& source, const Point& target, 
       const Point& leftNormal, const Point& rightNormal, 
       const int adjacentFaceIndex);
        
  void
  make(const Point& source, const Point& target, 
       const Point& leftNormal, const Point& rightNormal, 
       const int adjacentFaceIndex);
        
  Edge(const Edge& other);
        
  Edge& 
  operator=(const Edge& other);
        
  ~Edge()
  {}
        
  //-------------------------------------------------------------------------

        
  const Point& 
  getSource() const { 
    return _segment.getSource(); 
  }
        
  const Point& 
  getTarget() const { 
    return _segment.getTarget(); 
  }
        
  const Point& 
  getTangent() const { 
    return _segment.getTangent(); 
  }
        
  Number
  getLength() const { 
    return _segment.getLength(); 
  }
        
  const Point& 
  getLeftFaceNormal() const { 
    return _leftFaceNormal; 
  }
        
  const Point& 
  getRightFaceNormal() const { 
    return _rightFaceNormal; 
  }
        
  const Point& 
  getLeftSideNormal() const { 
    return _leftSideNormal; 
  }
        
  const Point& 
  getRightSideNormal() const { 
    return _rightSideNormal; 
  }
        
  int 
  getFaceIndex() const { 
    return _adjacentFaceIndex; 
  }
        
  int 
  getSignOfDistance() const
  { 
    return _signOfDistance; 
  }
        
  //-------------------------------------------------------------------------

        
  bool 
  isValid() const;
        
  Number 
  computeDistance(const Point& p) const;
        
  Number
  computeDistanceChecked(const Point& p) const;
        
  Number 
  computeDistanceUnsigned(const Point& p) const;
        
  Number 
  computeDistanceUnsignedChecked(const Point& p) const;
        
        
        
  Number 
  computeClosestPoint(const Point& p, Point* cp) const;
        
  Number 
  computeClosestPointChecked(const Point& p, Point* cp) const;
        
  Number 
  computeClosestPointUnsigned(const Point& p, Point* cp) const;
        
  Number 
  computeClosestPointUnsignedChecked(const Point& p, Point* cp) const;
        
        
        
  Number 
  computeGradient(const Point& p, Point* grad) const;
        
  Number 
  computeGradientChecked(const Point& p, Point* grad) const;
        
  Number 
  computeGradientUnsigned(const Point& p, Point* grad) const;
        
  Number 
  computeGradientUnsignedChecked(const Point& p, Point* grad) const;
        
        
        
  Number 
  computeClosestPointAndGradient(const Point& p, Point* cp, 
                                 Point* grad) const;
        
  Number 
  computeClosestPointAndGradientChecked(const Point& p, Point* cp, 
                                        Point* grad) const;
        
  Number 
  computeClosestPointAndGradientUnsigned(const Point& p, Point* cp, 
                                         Point* grad) const;
        
  Number 
  computeClosestPointAndGradientUnsignedChecked(const Point& p, Point* cp,
                                                Point* grad) const;
        
        
  void 
  buildCharacteristicPolyhedron(Polyhedron* polyhedron, 
                                Number height) const;
        
  void 
  buildCharacteristicPolyhedronUnsigned(Polyhedron* polyhedron, 
                                        Number height) const;
        
        
private:
                
  bool 
  isInside(const Point& pt, Number delta) const;
        
  bool 
  isInside(const Point& p) const { 
    return isInside(p, _epsilon);
  }
        
        
};


template<typename T>
bool 
operator==(const Edge<3,T>& a, const Edge<3,T>& b);


template<typename T>
bool 
operator!=(const Edge<3,T>& a, const Edge<3,T>& b);


template<typename T>
std::ostream& 
operator<<(std::ostream& out, const Edge<3,T>& edge);

END_NAMESPACE_CPT

#define __cpt_Edge_ipp__
#include "Edge.ipp"
#undef __cpt_Edge_ipp__

#endif

---