plane3.h

Go to the documentation of this file.

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

#ifndef BALL_MATHS_PLANE3_H
#define BALL_MATHS_PLANE3_H

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

#include <math.h>
#include <iostream>

#ifndef BALL_MATHS_LINE3_H
# include <BALL/MATHS/line3.h>
#endif

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

#ifndef BALL_MATHS_COMMON_H
# include <BALL/MATHS/common.h>
#endif

namespace BALL 
{
  
  template <typename T>
  class TPlane3;

  template <typename T>
  std::istream& operator >> (std::istream& s, TPlane3<T>& plane);

  template <typename T>
  std::ostream& operator << (std::ostream& s, const TPlane3<T>& plane);

  template <typename T>
  class TPlane3
  {
    public:

    BALL_CREATE(TPlane3<T>)

    

    TPlane3()
      
      : p(),
        n()
    {
    }

    TPlane3(const TPlane3& plane)
      
      : p(plane.p),
        n(plane.n)
    {
    }

    TPlane3(const TVector3<T>& point, const TVector3<T>& normal)
      
      : p(point),
        n(normal)
    {
    }

    TPlane3(const TVector3<T>& a, const TVector3<T>& b, const TVector3<T>& c)
      
      : p(a),
        n((a - b) % (b - c))
    {
    }

    TPlane3(const T& a, const T& b, const T& c, const T& d)
      throw(Exception::DivisionByZero)
    {
      n = TVector3<T>(a, b, c);
      if (a == 0 && b == 0 && c == 0)
      {
        throw Exception::DivisionByZero(__FILE__, __LINE__);      
      }
      if (!Maths::isZero(a))
      {
        p.set(-d / a, 0, 0);
      }
      else if (!Maths::isZero(b))
      {
        p.set(0, -d / b, 0);
      }
      else if (!Maths::isZero(c))
      {
        p.set(0, 0, -d / c);
      }
    }

    virtual ~TPlane3()
      
    {
    }

    virtual void clear() 
      
    {
      n.clear();
      p.clear();
    }



    void swap(TPlane3& plane) 
    {
      TVector3<T> temp_point(p);
      p = plane.p;
      plane.p = temp_point;

      temp_point = n;
      n = plane.n;
      plane.n = temp_point;
    }

    void set(const TPlane3& plane)
      
    {
      p = plane.p;
      n = plane.n;
    }

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

    void set(const TVector3<T>& a, const TVector3<T>& b, const TVector3<T>& c)
      
    {
        p = a;
        n = (a - b) % (b - c);
    }

    TPlane3& operator = (const TPlane3& plane)
      
    {
      p = plane.p;
      n = plane.n;

      return *this;
    }

    void get(TPlane3& plane) const
      
    {
      plane.p = p;
      plane.n = n;
    }

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


    void normalize()
      throw(Exception::DivisionByZero)
    {
      T length = n.getLength();
      // throw an exception on zero length normal
      if (length == 0.0)
      {
        throw Exception::DivisionByZero(__FILE__, __LINE__);
      }

      n /= length;
    }

    void hessify()
      
    {
      normalize();
      if (Maths::isLess(n * p, 0))
      {
        n.negate();
      }
    }



    bool operator == (const TPlane3& plane) const
      
    {
      return (p == plane.p && n == plane.n);
    }

    bool operator != (const TPlane3& plane) const
      
    {
      return (p != plane.p || n != plane.n);
    }

    bool has(const TVector3<T>& point) const
      
    {
      return Maths::isZero(n * (point - p));
    }

    bool has(const TLine3<T>& line) const
      
    {
      return (Maths::isZero(n * line.d) && has(line.p));
    }


    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 << "  normal: " << n << std::endl;

      BALL_DUMP_STREAM_SUFFIX(s);
    }

    TVector3<T> p;

    TVector3<T> n;

  };

  template <typename T>
  std::istream& operator >> (std::istream& s, TPlane3<T>& plane)
    
  {
    char c;
    s >> c >> plane.p >>  plane.n >> c;
    return s;
  }

  template <typename T>
  std::ostream& operator << (std::ostream& s, const TPlane3<T>& plane)
    
  {
    return (s << '(' << plane.p << ' '  << plane.n << ')');
  }
  
  typedef TPlane3<float> Plane3;
  
} // namespace BALL

#endif // BALL_MATHS_PLANE3_H