SegmentMath.h

// -*- C++ -*-

#if !defined(__geom_SegmentMath_h__)
#define __geom_SegmentMath_h__

// If we are debugging the whole geom namespace.
#if defined(DEBUG_geom) && !defined(DEBUG_SegmentMath)
#define DEBUG_SegmentMath
#endif

#ifdef DEBUG_SegmentMath
#ifndef DEBUG_Segment
#define DEBUG_Segment
#endif
#endif

#include "Segment.h"
#include "content.h"

#include <iosfwd>
#include <cmath>

BEGIN_NAMESPACE_GEOM


template<int N, typename T = double>
class SegmentMath : 
  public Segment<N,T> {
  //
  // Private types.
  //

private:

  typedef Segment<N,T> Base;

public:

  typedef typename Base::Number Number;
  typedef typename Base::Point Point;
      
private:
    
  Point _tangent;
  T _length;
    
public:
    
  //--------------------------------------------------------------------------
  // @{

  SegmentMath() :
    Base(),
    _tangent(),
    _length() 
  {}

  SegmentMath(const Point& source, const Point& target);

  SegmentMath(const Segment<N,T>& s)
    : SegmentMath(s.source(), s.target()) 
  {}

  SegmentMath(const SegmentMath& other) : 
    Segment<N,T>(other.getSource(), other.getTarget()), 
    _tangent(other._tangent),
    _length(other._length) 
  {}

  SegmentMath& 
  operator=(const SegmentMath& other);

  ~SegmentMath() 
  {}

  void 
  make(const Point& source, const Point& target);

  // @}
  //--------------------------------------------------------------------------
  // @{

  //
  // Inherited from Segment.
  //

  using Base::getSource;

  using Base::getTarget;
    
  //
  // New.
  //

  const Point& 
  getTangent() const { 
    return _tangent; 
  }

  T 
  getLength() const { 
    return _length; 
  }
    
  // @}
  //--------------------------------------------------------------------------
  // @{

  SegmentMath& 
  operator+=(const Point& p);

  SegmentMath& 
  operator-=(const Point& p);

  // @}
  //--------------------------------------------------------------------------
  // @{

  bool 
  isValid() const;

  // @}
};
  
  
//
// Distance.
//

//
// Unary Operators.
//



template<int N, typename T>
inline
const SegmentMath<N,T>&
operator+(const SegmentMath<N,T>& x) {
  return x;
}



template<int N, typename T>
inline
SegmentMath<N,T> 
operator-(const SegmentMath<N,T>& x) {
  return SegmentMath<N,T>(x.getTarget(), x.getSource());
}


//
// Binary Operators.
//



template<int N, typename T>
SegmentMath<N,T> 
operator+(const SegmentMath<N,T>& s, 
          const typename SegmentMath<N,T>::Point& p);



template<int N, typename T>
SegmentMath<N,T> 
operator-(const SegmentMath<N,T>& s, 
          const typename SegmentMath<N,T>::Point& p);


//
// Equality Operators.
//



template<int N, typename T>
inline 
bool 
operator==(const SegmentMath<N,T>& x, const SegmentMath<N,T>& y) {
  return (Segment<N,T>(x) == Segment<N,T>(y) &&
           x.getTangent() == y.getTangent() && x.getLength() == y.getLength());
}



template<int N, typename T>
inline 
bool 
operator!=(const SegmentMath<N,T>& x, const SegmentMath<N,T>& y) {
  return !(x == y);
}


//
// Mathematical Functions.
//



template<int N, typename T>
T 
computeDistance(const SegmentMath<N,T>& segment, 
                const typename SegmentMath<N,T>::Point& x);



template<int N, typename T>
void
computeClosestPoint(const SegmentMath<N,T>& segment, 
                    const typename SegmentMath<N,T>::Point& x, 
                    typename SegmentMath<N,T>::Point* closestPoint);



template<int N, typename T>
T 
computeDistanceAndClosestPoint(const SegmentMath<N,T>& segment, 
                               const typename SegmentMath<N,T>::Point& x, 
                               typename SegmentMath<N,T>::Point* closestPoint);



template<int N, typename T>
T 
computeUnsignedDistanceToSupportingLine
(const SegmentMath<N,T>& segment, 
 const typename SegmentMath<N,T>::Point& x);



template<int N, typename T>
T 
computeUnsignedDistanceAndClosestPointToSupportingLine
(const SegmentMath<N,T>& segment, const typename SegmentMath<N,T>::Point& x, 
 typename SegmentMath<N,T>::Point* closestPoint);



template<typename T>
bool 
computeZIntersection(const SegmentMath<3,T>& segment, T* x, T* y, T z);


template<typename T>
bool
computeIntersection(const SegmentMath<2,T>& s1, const SegmentMath<2,T>& s2,
                    typename SegmentMath<2,T>::Point* intersectionPoint);


//
// File I/O Operators.
//



template<int N, typename T>
std::istream& 
operator>>(std::istream& in, SegmentMath<N,T>& s);



template<int N, typename T>
std::ostream& 
operator<<(std::ostream& out, const SegmentMath<N,T>& s);


END_NAMESPACE_GEOM

#define __geom_SegmentMath_ipp__
#include "SegmentMath.ipp"
#undef __geom_SegmentMath_ipp__
  
#endif

---