line3.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: line3.h,v 1.48 2004/07/05 20:57:28 oliver Exp $
//

#ifndef BALL_MATHS_LINE3_H
#define BALL_MATHS_LINE3_H

#ifndef BALL_COMMON_EXCEPTION_H
# include <BALL/COMMON/exception.h>
#endif

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

namespace BALL 
{

  template <typename T>
  class TLine3;
  
  template <typename T>
  std::ostream& operator << (std::ostream& s, const TLine3<T>& line)
    ;

  template <typename T>
  std::istream& operator >> (std::istream& s, TLine3<T>& line)
    ;
  
  template <typename T>
  class TLine3
  {
    public:

    BALL_CREATE(TLine3<T>)

    

    enum Form
    {
      FORM__PARAMETER  = 0,
      FORM__TWO_POINTS = 1
    };


    TLine3()
      
      : p(),
        d()
    {
    }

    TLine3(const TLine3& line)
      
      : p(line.p),
        d(line.d)
    {
    }

    // form: PARAMETER (default) or TWO_POINTS

    TLine3(const TVector3<T>& point, const TVector3<T>& vector, Form form = FORM__PARAMETER)
      
      : p(point),
        d((form == FORM__PARAMETER) 
          ? vector 
          : vector - point)
    {
    }

    virtual ~TLine3()
      
    {
    }

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



    void swap(TLine3& line)
      
    {
      TVector3<T> temp_point(p);
      p = line.p;
      line.p = temp_point;

      TVector3<T> temp_vector(d);
      d = line.d;
      line.d = temp_vector;
    }

    void set(const TLine3& line)
      
    {
      p = line.p;
      d = line.d;
    }

    void set(const TVector3<T>& point, const TVector3<T>& vector, Form form = FORM__PARAMETER)
      
    {
      p = point;
      if (form == FORM__PARAMETER) 
      {
        d = vector;
      }
      else 
      {
        d = vector - point;
      }
    }

    TLine3& operator = (const TLine3& line)
      
    {
      p = line.p;
      d = line.d;

      return *this;
    }

    void get(TLine3& line) const 
    {
      line.p = p;
      line.d = d;
    }

    void get(TVector3<T>& point,TVector3<T>& vector, Form form = FORM__PARAMETER) const
      
    {
      point = p;
      if (form == FORM__PARAMETER) 
      {
        vector = d;
      }
      else 
      {
        vector - point = d;
      }
    }



    void normalize()
      
    {
      d.normalize();
    }


    bool operator == (const TLine3& line) const
      
    {
      return (p == line.p && d == line.d);
    }

    bool operator != (const TLine3& line) const
      
    {
      return (p != line.p || d != line.d);
    }

    bool has(const TVector3<T>& point) const
      
    {
      if (Maths::isNotZero(d.x))
      {
        T c = (point.x - p.x) / d.x;

        return (Maths::isEqual(p.y + c * d.y, point.y) && Maths::isEqual(p.z + c * d.z, point.z));
      }
      else 
      {
        if (Maths::isNotZero(d.y))
        {
          T c = (point.y - p.y) / d.y;

          return (Maths::isEqual(p.x, point.x)   // invariant: d.x == 0
                        && Maths::isEqual(p.z + c * d.z, point.z));
        }
        else 
        {
          if (Maths::isNotZero(d.z))
          {
            return (Maths::isEqual(p.x, point.x)   // invariant: d.x == 0
                          && Maths::isEqual(p.y, point.y)); // invariant: d.y == 0
          }
          else 
          {
            return false;
          }
        }
      }
    }



    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 << "  direction: " << d << std::endl;

      BALL_DUMP_STREAM_SUFFIX(s);
    }



    TVector3<T> p;

    TVector3<T> d;
  };

  typedef TLine3<float> Line3;

  template <typename T>
  std::istream& operator >> (std::istream& s, TLine3<T>& line)
    
  {
    char c;
    s >> c >> line.p >> line.d >> c;
    return s;
  }

  template <typename T>
  std::ostream& operator << (std::ostream& s, const TLine3<T>& line)
    
  {
    s << '(' << line.p << ' ' << line.d << ')';
    return s;
  }
} // namespace BALL

#endif // BALL_MATHS_LINE3_H