CircularArc3.h

// -*- C++ -*-

#if !defined(__geom_kernel_CircularArc3_h__)
#define __geom_kernel_CircularArc3_h__

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

#ifdef DEBUG_CircularArc3
#ifndef DEBUG_Point
#define DEBUG_Point
#endif
#endif

#include "Circle3.h"

#include "../../numerical/constants.h"

BEGIN_NAMESPACE_GEOM


template<typename T = double>
class CircularArc3 {
  //
  // Types
  //

public:
    
  typedef T Number;
  typedef ads::FixedArray<3,Number> Point;

private:

  typedef Circle3<Number> Circle;

  //
  // Data
  //

private:
    
  Circle _circle;
  Point _axis0, _axis1;
  Number _angle;

public:
    
  //--------------------------------------------------------------------------
  // @{

  CircularArc3() 
  {}

  CircularArc3(const Point& center, const Point& source, 
               const Point& target) : 
    _circle(),
    _axis0(),
    _axis1(),
    _angle() {
    make(center, source, target);
  }

  CircularArc3(const CircularArc3& other) :
    _circle(other._circle),
    _axis0(other._axis0),
    _axis1(other._axis1),
    _angle(other._angle)
  {}

  CircularArc3& 
  operator=(const CircularArc3& other);

  ~CircularArc3() 
  {}

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

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

  const Circle&
  getCircle() const { 
    return _circle; 
  }

  const Point&
  getCenter() const { 
    return _circle.getCenter(); 
  }

  Number
  getRadius() const { 
    return _circle.getRadius(); 
  }

  const Point&
  getFirstAxis() const { 
    return _axis0; 
  }

  const Point&
  getSecondAxis() const { 
    return _axis1; 
  }

  Number
  getAngle() const { 
    return _angle; 
  }
    
  // @}
  //--------------------------------------------------------------------------
  // @{


  Point
  operator()(const Number t) const {
    Point x = getCenter() + getRadius() * (std::cos(_angle * t) * _axis0 + 
                                           std::sin(_angle * t) * _axis1);
    return x;
  }

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

  CircularArc3& 
  operator+=(const Point& x) {
    _circle += x;
    return (*this);
  }

  CircularArc3& 
  operator-=(const Point& x) {
    _circle -= x;
    return (*this);
  }

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

  
  bool
  isValid() const;
  
};


//
// Mathematical functions.
//


template<typename T>
void 
computeClosestPoint(const CircularArc3<T>& circularArc, 
                    typename CircularArc3<T>::Point x,
                    typename CircularArc3<T>::Point* closestPoint);


template<typename T>
void 
computeClosestPoint(const Circle3<T>& circle,
                    const CircularArc3<T>& circularArc,
                    typename CircularArc3<T>::Point* closestPoint,
                    T tolerance = std::sqrt(std::numeric_limits<T>::epsilon()),
                    int maximumSteps = 10);


//
// Equality Operators.
//



template<typename T>
inline
bool 
operator==(const CircularArc3<T>& x, const CircularArc3<T>& y) {
  return (x.getCircle() == y.getCircle() && 
          x.getFirstAxis() == y.getFirstAxis() && 
          x.getSecondAxis() == y.getSecondAxis() && 
          x.getAngle() == y.getAngle());
}



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


//
// Binary Operators.
//


template<typename T>
inline
CircularArc3<T> 
operator+(const CircularArc3<T>& circularArc, 
          const typename CircularArc3<T>::Point& vector) {
  CircularArc3<T> x(circularArc);
  x += vector;
  return x;
}



template<typename T>
inline
CircularArc3<T> 
operator-(const CircularArc3<T>& circularArc, 
          const typename CircularArc3<T>::Point& vector) {
  CircularArc3<T> x(circularArc);
  x -= vector;
  return x;
}


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



template<typename T>
std::istream& 
operator>>(std::istream& in, CircularArc3<T>& x);



template<typename T>
inline
std::ostream& 
operator<<(std::ostream& out, const CircularArc3<T>& x) {
  return out << x.getCenter() << " " << x(0.0) << " " << x(1.0);
}


END_NAMESPACE_GEOM

#define __geom_kernel_CircularArc3_ipp__
#include "CircularArc3.ipp"
#undef __geom_kernel_CircularArc3_ipp__
  
#endif

---