TCMathCoord2D.h

Go to the documentation of this file.

//*******************************************************************************
//
// *******   ***   ***               *
//    *     *     *                  *
//    *    *      *                *****
//    *    *       ***  *   *   **   *    **    ***
//    *    *          *  * *   *     *   ****  * * *
//    *     *         *   *      *   * * *     * * *
//    *      ***   ***    *     **   **   **   *   *
//                        *
//*******************************************************************************
// see http://sourceforge.net/projects/tcsystem/ for details.
// Copyright (C) 2003 - 2008 Thomas Goessler. All Rights Reserved. 
//*******************************************************************************
//
// TCSystem is the legal property of its developers.
// Please refer to the COPYRIGHT file distributed with this source distribution.
// 
// This library is free software; you can redistribute it and/or             
// modify it under the terms of the GNU Lesser General Public                
// License as published by the Free Software Foundation; either              
// version 2.1 of the License, or (at your option) any later version.        
//                                                                           
// This library is distributed in the hope that it will be useful,           
// but WITHOUT ANY WARRANTY; without even the implied warranty of            
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         
// Lesser General Public License for more details.                           
//                                                                           
// You should have received a copy of the GNU Lesser General Public          
// License along with this library; if not, write to the Free Software       
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
//*******************************************************************************
//  $Id: TCMathCoord2D.h 801 2008-01-23 19:46:25Z the_____tiger $
//*******************************************************************************

#ifndef _TCCOORD_2D_H_
#define _TCCOORD_2D_H_

#include "TCMathUtil.h"
#include "TCStream.h"
#include "TCUtil.h"

#include <cmath>

namespace TC
{
namespace Math
{
   template <class T>
   class Coord2D
   {
   public:
      Coord2D(T vIn=(T)0)
      {
         m_data[0]=vIn;
         m_data[1]=vIn;
      }
      Coord2D(const T xIn, const T yIn)
      {
         m_data[0]=xIn;
         m_data[1]=yIn;
      }
      Coord2D(const Coord2D<T>& a)
      {
         m_data[0]=a.m_data[0];
         m_data[1]=a.m_data[1];
      } 
      // --------------------------------------------------

      // --------------------------------------------------
      // accesing values
      const T& operator[] (sint32 pos) const { return m_data[pos];}
      // setting values
      T& operator[] (sint32 pos) { return m_data[pos];}
      // --------------------------------------------------

      // --------------------------------------------------
      // Assignment operators
      Coord2D<T>& operator=(const Coord2D<T>& a)  { m_data[0]=a.m_data[0]; m_data[1]=a.m_data[1]; return *this;}
      Coord2D<T>& operator=(const T &vIn)         { m_data[0]=m_data[1]=vIn; return *this;}
      Coord2D<T>& operator+=(const Coord2D<T>& b) { m_data[0]+=b.m_data[0]; m_data[1]+=b.m_data[1]; return *this;}
      Coord2D<T>& operator+=(const T &b)          { m_data[0]+=b; m_data[1]+=b; return *this;}
      Coord2D<T>& operator-=(const Coord2D<T>& b) { m_data[0]-=b.m_data[0]; m_data[1]-=b.m_data[1]; return *this;}
      Coord2D<T>& operator-=(const T &b)          { m_data[0]-=b; m_data[1]-=b; return *this;}
      Coord2D<T>& operator*=(const T &vIn)        { m_data[0]*=vIn; m_data[1]*=vIn; return *this;}
      Coord2D<T>& operator/=(const T &vIn)        { m_data[0]/=vIn; m_data[1]/=vIn; return *this;}
      // --------------------------------------------------

      operator T*() {return m_data;}
      operator const T*() const {return m_data;}

      T* GetPtr()       {return m_data;}
      const T* GetPtr() const {return m_data;}
      double Length2() const { return (m_data[0]*m_data[0] + m_data[1]*m_data[1]);}
      double Length () const { return std::sqrt(Length2());}
      void Normalize()                                                    
      {
         double len = Length2();
         if (len > 0.0)
         {
            len = std::sqrt(len);
            m_data[0] = (T)((double)(m_data[0])/len);
            m_data[1] = (T)((double)(m_data[1])/len);
         }
      }
      T MaxValue() const
      {
         return Util::Max(m_data[0], m_data[1]);
      }

      typedef T DataType;
      enum
      {
         NUM_COMPONENTS = 2
      };
   private:
      T m_data[NUM_COMPONENTS];
   };

   template <class T>
   inline const Coord2D<T> operator*(const Coord2D<T> &v, const T &vIn)
   {
      return Coord2D<T>(v[0]*vIn, v[1]*vIn);
   }

   template <class T>
   inline const Coord2D<T> operator*(const T &vIn, const Coord2D<T> &v)
   {
      return Coord2D<T>(v[0]*vIn, v[1]*vIn);
   }

   template <class T>
   inline const T operator*(const Coord2D<T> &a, const Coord2D<T> &b)
   {
      return (a[0] * b[0] + a[1] * b[1]);
   }

   template <class T>
   inline const Coord2D<T> operator/(const Coord2D<T> &v, const T &vIn)
   {
      return Coord2D<T>(v[0]/vIn, v[1]/vIn);
   }

   template <class T>
   inline const Coord2D<T> operator/(const T &vIn, const Coord2D<T> &v)
   {
      return Coord2D<T>(v[0]/vIn, v[1]/vIn);
   }

   template <class T>
   inline const Coord2D<T> operator+(const Coord2D<T>& v, const Coord2D<T>& b)
   {
      return Coord2D<T>(v[0]+b[0], v[1]+b[1]);
   }

   template <class T>
   inline const Coord2D<T> operator+(const Coord2D<T>& v, const T& b)
   {
      return Coord2D<T>(v[0]+b, v[1]+b);
   }

   template <class T>
   inline const Coord2D<T> operator-(const Coord2D<T>& v, const Coord2D<T>& b)
   {
      return Coord2D<T>(v[0]-b[0], v[1]-b[1]);
   }

   template <class T>
   inline const Coord2D<T> operator-(const Coord2D<T>& v, const T& b)
   {
      return Coord2D<T>(v[0]-b, v[1]-b);
   }

   template <class T>
   inline const Coord2D<T> operator-(const Coord2D<T>& v)
   {
      return Coord2D<T>(-v[0], -v[1]);
   }

   // ------------------------------------------------------------------------------------------------------------
   // operators for coordinates checking
   // ------------------------------------------------------------------------------------------------------------
   template <class T>
   inline bool operator>(const Coord2D<T>&a, const Coord2D<T>&b)
   {
      if (a[0] > b[0]) return true;
      if (a[0] < b[0]) return false;
      if (a[1] > b[1]) return true;
      if (a[1] < b[1]) return false;
      return 0;
   }

   template <class T>
   inline bool operator<(const Coord2D<T>&a, const Coord2D<T>&b)
   {
      if (a[0] < b[0]) return true;
      if (a[0] > b[0]) return false;
      if (a[1] < b[1]) return true;
      if (a[1] > b[1]) return false;
      return false;
   }

   template <class T>
   inline bool operator==(const Coord2D<T>&a, const Coord2D<T>&b)
   {
      return (a[0]==b[0] && a[1]==b[1]);
   }

   template <class T>
   inline bool operator!=(const Coord2D<T>&a, const Coord2D<T>&b)
   {
      return (a[0]!=b[0] || a[1]!=b[1]);
   }

   template <class T>
   inline bool operator>=(const Coord2D<T>&a, const Coord2D<T>&b)
   {
      return (a==b || a>b);
   }

   template <class T>
   inline bool operator<=(const Coord2D<T>&a, const Coord2D<T>&b)
   {
      return (a==b || a<b);
   }

   template <class T>
   inline StreamPtr operator>>(StreamPtr stream, Coord2D<T>& coord)
   {
      return stream >> coord[0] >> coord[1];
   }
   template <class T>
   inline StreamPtr operator<<(StreamPtr stream, const Coord2D<T>& coord)
   {
      return stream << coord[0] << space << coord[1];
   }

} // namespace Math
} // namespace TC

#endif // _TCCOORD_2D_H_