simgear/math/SGSphere.hxx

   1 // Copyright (C) 2006  Mathias Froehlich - Mathias.Froehlich@web.de
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Library General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Library General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program; if not, write to the Free Software
  15 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  16 //
  17
  18 #ifndef SGSphere_H
  19 #define SGSphere_H
  20
  21
  22 template<typename T>
  23 class SGSphere {
  24 public:
  25
  26 #ifdef __GNUC__
  27 // Avoid "_center not initialized" warnings.
  28 #   pragma GCC diagnostic ignored "-Wuninitialized"
  29 #endif
  30
  31   SGSphere() :
  32      /*
  33       * Do not initialize _center to save unneeded initialization time.
  34       * Fix 'may be used uninitialized' warnings locally instead
  35       */
  36 //  _center(0.0, 0.0, 0.0),
  37     _radius(-1)
  38   { }
  39   SGSphere(const SGVec3<T>& center, const T& radius) :
  40     _center(center),
  41     _radius(radius)
  42   { }
  43   template<typename S>
  44   explicit SGSphere(const SGSphere<S>& sphere) :
  45     _center(sphere.getCenter()),
  46     _radius(sphere.getRadius())
  47   { }
  48
  49 #ifdef __GNUC__
  50   // Restore warning settings.
  51 #   pragma GCC diagnostic warning "-Wuninitialized"
  52 #endif
  53
  54   const SGVec3<T>& getCenter() const
  55   { return _center; }
  56   void setCenter(const SGVec3<T>& center)
  57   { _center = center; }
  58
  59   const T& getRadius() const
  60   { return _radius; }
  61   void setRadius(const T& radius)
  62   { _radius = radius; }
  63   T getRadius2() const
  64   { return _radius*_radius; }
  65
  66   bool empty() const
  67   { return !valid(); }
  68
  69   bool valid() const
  70   { return 0 <= _radius; }
  71
  72   void clear()
  73   { _radius = -1; }
  74
  75   /// Return true if this is inside sphere
  76   bool inside(const SGSphere<T>& sphere) const
  77   {
  78     if (empty())
  79       return false;
  80     if (sphere.empty())
  81       return false;
  82
  83     T dist = sphere.getRadius() - getRadius();
  84     return distSqr(getCenter(), sphere.getCenter()) <= dist*dist;
  85   }
  86
  87   void expandBy(const SGVec3<T>& v)
  88   {
  89     if (empty()) {
  90       _center = v;
  91       _radius = 0;
  92       return;
  93     }
  94
  95     T dist2 = distSqr(_center, v);
  96     if (dist2 <= getRadius2())
  97       return;
  98
  99     T dist = sqrt(dist2);
 100     T newRadius = T(0.5)*(_radius + dist);
 101     _center += ((newRadius - _radius)/dist)*(v - _center);
 102     _radius = newRadius;
 103   }
 104
 105   void expandBy(const SGSphere<T>& s)
 106   {
 107     if (s.empty())
 108       return;
 109
 110     if (empty()) {
 111       _center = s.getCenter();
 112       _radius = s.getRadius();
 113       return;
 114     }
 115
 116     T dist = length(_center - s.getCenter());
 117     if (dist <= SGLimits<T>::min()) {
 118       _radius = SGMisc<T>::max(_radius, s._radius);
 119       return;
 120     }
 121
 122     // already included
 123     if (dist + s.getRadius() <= _radius)
 124       return;
 125
 126     // new one includes all
 127     if (dist + _radius <= s.getRadius()) {
 128       _center = s.getCenter();
 129       _radius = s.getRadius();
 130       return;
 131     }
 132
 133     T newRadius = T(0.5)*(_radius + dist + s.getRadius());
 134     T ratio = (newRadius - _radius) / dist;
 135     _radius = newRadius;
 136
 137     _center[0] += ratio*(s._center[0] - _center[0]);
 138     _center[1] += ratio*(s._center[1] - _center[1]);
 139     _center[2] += ratio*(s._center[2] - _center[2]);
 140   }
 141
 142   void expandBy(const SGBox<T>& box)
 143   {
 144     if (box.empty())
 145       return;
 146
 147     if (empty()) {
 148       _center = box.getCenter();
 149       _radius = T(0.5)*length(box.getSize());
 150       return;
 151     }
 152
 153     SGVec3<T> boxCenter = box.getCenter();
 154     SGVec3<T> corner;
 155     for (unsigned i = 0; i < 3; ++i) {
 156       if (_center[i] < boxCenter[i])
 157         corner[i] = box.getMax()[i];
 158       else
 159         corner[i] = box.getMin()[i];
 160     }
 161     expandBy(corner);
 162   }
 163
 164 private:
 165   SGVec3<T> _center;
 166   T _radius;
 167 };
 168
 169 /// Output to an ostream
 170 template<typename char_type, typename traits_type, typename T>
 171 inline
 172 std::basic_ostream<char_type, traits_type>&
 173 operator<<(std::basic_ostream<char_type, traits_type>& s,
 174            const SGSphere<T>& sphere)
 175 {
 176   return s << "center = " << sphere.getCenter()
 177            << ", radius = " << sphere.getRadius();
 178 }
 179
 180 #endif