Ball.h

// -*- C++ -*-

#if !defined(__geom_kernel_Ball_h__)
#define __geom_kernel_Ball_h__

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

#ifdef DEBUG_Ball
#ifndef DEBUG_Point
#define DEBUG_Point
#endif
#endif

#include "Point.h"

BEGIN_NAMESPACE_GEOM


template<int N, typename T = double>
class Ball {
  //
  // Types
  //

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

  //
  // Data
  //

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

  Ball() 
  {}

  Ball(const Point& center, const Number radius) : 
    _center(center),
    _radius(radius) 
  {}

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

  Ball& 
  operator=(const Ball& other);

  ~Ball() 
  {}

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

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

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

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

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

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

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

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

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

  
  bool
  isInside(const Point& position) const {
    return computeSquaredDistance(_center, position) < _radius * _radius;
  }
  
};


//
// Equality Operators.
//


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



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


//
// Binary Operators.
//


template<int N, typename T>
inline
Ball<N,T> 
operator+(const Ball<N,T>& b, const typename Ball<N,T>::Point& p) {
  return Ball<N,T>(b.getCenter() + p, b.getRadius());
}


template<int N, typename T>
inline
Ball<N,T> 
operator-(const Ball<N,T>& b, const typename Ball<N,T>::Point& p) {
  return Ball<N,T>(b.getCenter() - p, b.getRadius());
}


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


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


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

END_NAMESPACE_GEOM

#define __geom_kernel_Ball_ipp__
#include "Ball.ipp"
#undef __geom_kernel_Ball_ipp__
  
#endif

---