sphere3.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: sphere3.h,v 1.39 2004/05/27 19:49:42 oliver Exp $
//

#ifndef BALL_MATHS_SPHERE3_H
#define BALL_MATHS_SPHERE3_H

#ifdef BALL_HAS_IEEEFP_H
# include <ieeefp.h>
#endif

#include <iostream>

#ifndef BALL_MATHS_PLANE3_H
# include <BALL/MATHS/plane3.h>
#endif

#ifndef BALL_MATHS_VECTOR3_H
# include <BALL/MATHS/vector3.h>
#endif

namespace BALL 
{

  template <typename T>
  class TSphere3
  {
    public:

    BALL_CREATE(TSphere3)

    

    TSphere3()
      
      : p(),
        radius(0)
    {
    }

    TSphere3(const TSphere3& sphere)
      
      : p(sphere.p),
        radius(sphere.radius)
    {
    }

    TSphere3(const TVector3<T>& point, const T& radius)
      
      : p(point),
        radius(radius)
    {
    }

    virtual ~TSphere3()
      
    {
    }

    virtual void clear()
      
    {
      p.clear();
      radius = (T) 0;
    }


    void swap(TSphere3& sphere)
      
    {
      TVector3<T> temp_point(p);
      p = sphere.p;
      sphere.p = temp_point;

      T temp = radius;
      radius = sphere.radius;
      sphere.radius = temp;
    }

    void set(const TSphere3& sphere)
      
    {
      p = sphere.p;
      radius = sphere.radius;
    }

    void set(const TVector3<T>& point, const T& r)
      
    {
      p = point;
      radius = r;
    }

    TSphere3& operator = (const TSphere3& sphere)
      
    {
      p = sphere.p;
      radius = sphere.radius;
      return *this;
    }

    void get(TSphere3& sphere) const
      
    {
      sphere.p = p;
      sphere.radius = radius;
    }

    void get(TVector3<T>& point, T& r) const
      
    {
      point = p;
      r = radius;
    }



    bool operator == (const TSphere3& sphere) const
      
    {
      return (p == sphere.p && Maths::isEqual(radius, sphere.radius));
    }

    bool operator != (const TSphere3& sphere) const
      
    {
      return (p != sphere.p || Maths::isNotEqual(radius, sphere.radius));
    }

    bool has(const TVector3<T>& point, bool on_surface = false) const
      
    {
      if (on_surface)
      {
        return Maths::isEqual(p.getDistance(point), radius);
      } 
      else 
      {
        return Maths::isLessOrEqual(p.getDistance(point), radius);
      }
    }

    bool isEmpty() const
      
    {
      return Maths::isZero(radius);
    }



    bool isValid() const
      
    {
      return true;
    }

    void dump(std::ostream& s = std::cout, Size depth = 0) const
      
    {
      BALL_DUMP_STREAM_PREFIX(s);

      BALL_DUMP_HEADER(s, this, this);

      BALL_DUMP_DEPTH(s, depth);
      s << "  position: " << p << std::endl;

      BALL_DUMP_DEPTH(s, depth);
      s << "  radius: " << radius << std::endl;

      BALL_DUMP_STREAM_SUFFIX(s);
    }



    TVector3<T> p;

    T radius;

  };


  template <typename T>
  std::istream& operator >> (std::istream& s, TSphere3<T>& sphere)
    
  {
    char c;
    s >> c >> sphere.p >> sphere.radius >> c;
    return s;
  }

  template <typename T>
  std::ostream& operator << (std::ostream& s, const TSphere3<T>& sphere)
    
  {
    s << '(' << sphere.p << ' ' << sphere.radius << ')';
    return s;
  }
  
  typedef TSphere3<float> Sphere3;

} // namespace BALL

#endif // BALL_MATHS_SPHERE3_H

---