Line_2.h

// -*- C++ -*-

#if !defined(__geom_Line_2_h__)
#define __geom_Line_2_h__

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

#include <iostream>
#include <cassert>
#include <cmath>

#include "SegmentMath.h"

BEGIN_NAMESPACE_GEOM


template<typename T = double>
class Line_2 {
public:

  //
  // Public types.
  //

  typedef T Number;
  typedef SegmentMath<2,T> Segment;
  typedef typename Segment::Point Point;

private:

  //
  // Member data
  //

  Segment _segment;
  Point _normal;

public:

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

  Line_2()
  {}

  Line_2(const Point& source, const Point& target) : 
    _segment(source, target),
    _normal(_segment.getTangent()[1], - _segment.getTangent()[0])
  {}

  void
  make(const Point& source, const Point& target) {
    _segment.make(source, target);
    _normal[0] = _segment.getTangent()[1];
    _normal[1] = - _segment.getTangent()[0];
  }

  Line_2(const Segment& segment) : 
    _segment(segment),
    _normal(_segment.getTangent()[1], - _segment.getTangent()[0])
  {}

  Line_2(const geom::Segment<2,Number>& segment) : 
    _segment(segment),
    _normal(_segment.getTangent()[1], - _segment.getTangent()[0])
  {}

  Line_2(const Line_2& other) : 
    _segment(other._segment),
    _normal(other._normal)
  {}

  Line_2& 
  operator=(const Line_2& other);

  ~Line_2()
  {}

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

  const Point& 
  getPointOn() const {
    return _segment.getSource();
  }

  const Point& 
  getTangent() const {
    return _segment.getTangent();
  }

  const Point& 
  getNormal() const {
    return _normal;
  }
        
  const Segment& 
  getSegment() const {
    return _segment;
  }

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

  // CONTINUE
#if 0
  Segment& 
  segment() {
    return _segment;
  }
#endif

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

  Line_2& 
  operator+=(const Point& p) {
    _segment += p;
    return *this;
  }

  Line_2& 
  operator-=(const Point& p) {
    _segment -= p;
    return *this;
  }

  Number 
  computeSignedDistance(const Point& p) const {
    return computeDotProduct(p - getPointOn(), getNormal());
  }

  Number 
  computeSignedDistanceAndClosestPoint(const Point& p, Point* cp) const
  {
    *cp = getPointOn() + computeDotProduct(p - getPointOn(), 
                                           getTangent()) * getTangent();
    return computeDotProduct(p - getPointOn(), getNormal());
  }

  void 
  computeIntersection(Point p1, Point p2, Point* intersectionPoint) const;

  // @}    
};


//
// Mathematical Functions.
//



template<typename T>
inline
const Line_2<T>& 
operator+(const Line_2<T>& x) {
  return x;
}



template<typename T>
inline
Line_2<T>
operator-(const Line_2<T>& x) {
  return Line_2<T>(- x.getSegment());
}


//
// File I/O.
//



template<typename T>
inline
std::istream& 
operator>>(std::istream& in, Line_2<T>& x) {
  typename Line_2<T>::Point p, q;
  in >> p >> q;
  x = Line_2<T>(p, q);
  return in;
}



template<typename T>
inline
std::ostream& 
operator<<(std::ostream& out, const Line_2<T>& x) {
  out << x.getSegment() << x.getNormal() << '\n';
  return out;
}


//
// Equality Operators.
//



template<typename T>
inline
bool
operator==(const Line_2<T>& a, const Line_2<T>& b) {
  return a.getSegment() == b.getSegment();
}



template<typename T>
inline
bool
operator!=(const Line_2<T>& a, const Line_2<T>& b) {
  return !(a == b);
}


END_NAMESPACE_GEOM

#define __geom_Line_2_ipp__
#include "Line_2.ipp"
#undef __geom_Line_2_ipp__

#endif

---