Circle3.h

// -*- C++ -*-

#if !defined(__geom_kernel_Circle3_h__)
#define __geom_kernel_Circle3_h__

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

#ifdef DEBUG_Circle3
#ifndef DEBUG_Point
#define DEBUG_Point
#endif
#endif

#include "Point.h"
#include "SegmentMath.h"

BEGIN_NAMESPACE_GEOM


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

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

  //
  // Data
  //

private:
    
  Point _center;
  Point _normal;
  Number _radius;
    
public:
    
  //--------------------------------------------------------------------------
  // @{

  Circle3() 
  {}

  Circle3(const Point& center, const Point& normal, const Number radius) : 
    _center(center),
    _normal(normal),
    _radius(radius) 
  {}

  Circle3(const Circle3& other) :
    _center(other._center),
    _normal(other._normal),
    _radius(other._radius) 
  {}

  Circle3& 
  operator=(const Circle3& other);

  ~Circle3() 
  {}

  void 
  make(const Point& center, const Point& normal, const Number radius) { 
    _center = center;
    _normal = normal;
    _radius = radius;
  }

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

  const Point&
  getCenter() const { 
    return _center; 
  }

  const Point&
  getNormal() const { 
    return _normal; 
  }

  Number
  getRadius() const { 
    return _radius; 
  }
    
  // @}
  //--------------------------------------------------------------------------
  // @{

  void
  setCenter(const Point& center) { 
    _center = center;
  }

  void
  setNormal(const Point& normal) { 
    _normal = normal;
  }

  void
  setRadius(const Number radius) { 
    _radius = radius;
  }
    
  // @}
  //--------------------------------------------------------------------------
  // @{

  Circle3& 
  operator+=(const Point& x) {
    _center += x;
    return (*this);
  }

  Circle3& 
  operator-=(const Point& x) {
    _center -= x;
    return (*this);
  }

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

  
  bool
  isValid() const;
  
};

//
// Mathematical functions.
//

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

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

//
// Equality Operators.
//


template<typename T>
inline
bool 
operator==(const Circle3<T>& x, const Circle3<T>& y) {
  return (x.getCenter() == y.getCenter() && x.getNormal() == y.getNormal() && 
          x.getRadius() == y.getRadius() );
}



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


//
// Binary Operators.
//


template<typename T>
inline
Circle3<T> 
operator+(const Circle3<T>& circle, const typename Circle3<T>::Point& vector) {
  return Circle3<T>(circle.getCenter() + vector, circle.getNormal(),
                    circle.getRadius());
}


template<typename T>
inline
Circle3<T> 
operator-(const Circle3<T>& circle, const typename Circle3<T>::Point& vector) {
  return Circle3<T>(circle.getCenter() - vector, circle.getNormal(),
                    circle.getRadius());
}


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


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


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


END_NAMESPACE_GEOM

#define __geom_kernel_Circle3_ipp__
#include "Circle3.ipp"
#undef __geom_kernel_Circle3_ipp__
  
#endif

---