Vector2d.hpp

Go to the documentation of this file.

/*
 * Copyright(c):
 * Signal Image and Communications (SIC) Department 
 * http://www.sic.sp2mi.univ-poitiers.fr/ 
 *  - University of Poitiers, France http://www.univ-poitiers.fr 
 *  - XLIM  Institute UMR CNRS 7252  http://www.xlim.fr/ 
 * 
 * and 
 * 
 * D2 Fluid, Thermic and Combustion 
 *  - University of Poitiers, France http://www.univ-poitiers.fr 
 *  - PPRIME Institute -  UPR CNRS 3346  http://www.pprime.fr
 *  - ISAE-ENSMA http://www.ensma.fr
 *
 * Contributor(s):
 * The SLIP team,
 * Benoit Tremblais <tremblais_AT_sic.univ-poitiers.fr>,
 * Laurent David <laurent.david_AT_lea.univ-poitiers.fr>, 
 * Ludovic Chatellier <ludovic.chatellier_AT_univ-poitiers.fr>, 
 * Lionel Thomas <lionel.thomas_AT_univ-poitiers.fr>, 
 * Denis Arrivault <arrivault_AT_sic.univ-poitiers.fr>, 
 * Julien Dombre <julien.dombre_AT_univ-poitiers.fr>.
 *
 * Description:
 * The Simple Library of Image Processing (SLIP) is a new image processing 
 * library. It is written in the C++ language following as much as possible 
 * the ISO/ANSI C++ standard. It is consequently compatible with any system  
 * satisfying the ANSI C++ complience. It works on different Unix , Linux ,  
 * Mircrosoft Windows and Mac OS X plateforms. SLIP is a research library that  
 * was created by the Signal, Image and Communications (SIC) departement of  
 * the XLIM, UMR 7252 CNRS Institute in collaboration with the Fluids, Thermic  
 * and Combustion departement of the P', UPR 3346 CNRS Institute of the  
 * University of Poitiers.
 * 
 * The SLIP Library source code has been registered to the APP (French Agency 
 * for the Protection of Programs) by the University of Poitiers and CNRS, 
 * under  registration number IDDN.FR.001.300034.000.S.P.2010.000.21000.

 * http://www.sic.sp2mi.univ-poitiers.fr/slip/
 *
 * This software is governed by the CeCILL-C license under French law and
 * abiding by the rules of distribution of free software.  You can  use, 
 * modify and/ or redistribute the software under the terms of the CeCILL-C 
 * license as circulated by CEA, CNRS and INRIA at the following URL 
 * http://www.cecill.info.
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 * 
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the 
 * same conditions as regards security. 
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-C license and that you accept its terms.
 */



#ifndef SLIP_VECTOR2D_HPP
#define SLIP_VECTOR2D_HPP

#include <iostream>
#include <iterator>
#include <cassert>
#include <cmath>
#include <string>
#include <cstddef>
#include "KVector.hpp"
#include "norms.hpp"
#include "macros.hpp"
#include "compare.hpp"

#include <boost/serialization/access.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/base_object.hpp>

namespace slip
{

template <typename T>
struct Vector2d;

template <typename T>
bool operator<(const Vector2d<T>& x, const Vector2d<T>& y);

template <typename T>
bool operator>(const Vector2d<T>& x, const Vector2d<T>& y);

template <typename T>
bool operator<=(const Vector2d<T>& x, const Vector2d<T>& y);

template <typename T>
bool operator>=(const Vector2d<T>& x, const Vector2d<T>& y);

template <typename T>
struct Vector2d : public kvector<T,2>
{

  typedef Vector2d<T> self;
  typedef T value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;

  typedef ptrdiff_t difference_type;
  typedef std::size_t size_type;

  typedef pointer iterator;
  typedef const_pointer const_iterator;



  Vector2d();

  Vector2d(const T& val);

  Vector2d(const T& x1,
                   const T& x2);

  Vector2d(const T* val);

  
  Vector2d(const Vector2d<T>& rhs);

  

//   Vector2d<T>& operator=(const Vector2d<T>& rhs)
//   {
//     (*this)[0] = rhs[0];
//     (*this)[1] = rhs[1];
//     return *this;
//   }


  self operator-() const;
  
  T angle() const;

  T angle_degree() const;
  


  friend bool operator< <>(const Vector2d<T>& x, const Vector2d<T>& y);

  friend bool operator> <>(const Vector2d<T>& x, const Vector2d<T>& y);

  friend bool operator<= <>(const Vector2d<T>& x, const Vector2d<T>& y);

  friend bool operator> <>(const Vector2d<T>& x, const Vector2d<T>& y);

 
  const T& get_x1() const;
  const T& get_x() const;
  const T& u() const;

  const T& get_x2() const;
  const T& get_y() const;
  const T& v() const;
    

  

  void set_x1(const T& x1);
  void set_x(const T& r);
  void u(const T& u_);
  

  void set_x2(const T& x2);
  void set_y(const T& g);
  void v(const T& v_);
 

  void set(const T& x1, 
                   const T& x2);


  std::string name() const;

  
 private:
    friend class boost::serialization::access;
    template<class Archive>
    void save(Archive & ar, const unsigned int version) const
    {
      ar & boost::serialization::base_object<slip::kvector<T,2> >(*this);
    }
   template<class Archive>
    void load(Archive & ar, const unsigned int version)
    {
      ar & boost::serialization::base_object<slip::kvector<T,2> >(*this);
    }
  BOOST_SERIALIZATION_SPLIT_MEMBER()
};

  typedef slip::Vector2d<double> Vector2d_d;
  typedef slip::Vector2d<float> Vector2d_f;
  typedef slip::Vector2d<long> Vector2d_l;
  typedef slip::Vector2d<unsigned long> Vector2d_ul;
  typedef slip::Vector2d<short> Vector2d_s;
  typedef slip::Vector2d<unsigned short> Vector2d_us;
  typedef slip::Vector2d<int> Vector2d_i;
  typedef slip::Vector2d<unsigned int> Vector2d_ui;
  typedef slip::Vector2d<char> Vector2d_c;
  typedef slip::Vector2d<unsigned char> Vector2d_uc;
}//slip::

namespace slip
{

  template<typename T>
  inline
  Vector2d<T>::Vector2d()
  {
    this->fill(T(0));
  }

  template<typename T>
  inline
  Vector2d<T>::Vector2d(const T& val)
  {
    this->fill(val);
  }

  template<typename T>
  inline
  Vector2d<T>::Vector2d(const T& x1,
                                                const T& x2)
  {
    (*this)[0] = x1;
    (*this)[1] = x2;
  }

  template<typename T>
  inline
  Vector2d<T>::Vector2d(const T* val)
  {
    assert(val != 0);
    this->fill(val);
  }


  template<typename T>
  inline
  Vector2d<T>::Vector2d(const Vector2d<T>& rhs)
  {
    *this = rhs; 
  }

  template<typename T>
  inline
   Vector2d<T> Vector2d<T>::operator-() const
  {
    self tmp;
    tmp[0] = -(*this)[0];
    tmp[1] = -(*this)[1];
    return tmp;
  }

  template<typename T>
  inline
  T Vector2d<T>::angle() const
  {
    return std::atan2((*this)[1],(*this)[0]);
  }

  template<typename T>
  inline
  T Vector2d<T>::angle_degree() const
  {
    return (static_cast<T>(180.0)/slip::constants<T>::pi()) * this->angle();
  }
 
  /* @{ */
  template<typename T>
  inline
  bool operator<(const Vector2d<T>& x, 
                                 const Vector2d<T>& y)
  {
     return (slip::Euclidean_norm<T>(x.begin(),x.end()) 
                     < 
                     slip::Euclidean_norm<T>(y.begin(),y.end()) 
                     );
  }

  

  template<typename T>
  inline
  bool operator>(const Vector2d<T>& x, 
                                 const Vector2d<T>& y)
  {
    return y < x;
  }

  template<typename T>
  inline
  bool operator<=(const Vector2d<T>& x, 
                                 const Vector2d<T>& y)
  {
    return !(y < x);
  }

  template<typename T>
  inline
  bool operator>=(const Vector2d<T>& x, 
                                 const Vector2d<T>& y)
  {
    return !(x < y);
  }
  /* @} */

  template<typename T>
  inline
  const T& Vector2d<T>::get_x1() const {return (*this)[0];}

  template<typename T>
  inline
  const T& Vector2d<T>::get_x() const {return (*this)[0];}

  template<typename T>
  inline
  const T& Vector2d<T>::u() const {return (*this)[0];}


   template<typename T>
  inline
  const T& Vector2d<T>::get_x2() const {return (*this)[1];}

  template<typename T>
  inline
  const T& Vector2d<T>::get_y() const {return (*this)[1];}

  template<typename T>
  inline
  const T& Vector2d<T>::v() const {return (*this)[1];}


  template<typename T>
  inline
  void Vector2d<T>::set_x1(const T& x1){(*this)[0] = x1;}

  template<typename T>
  inline
  void Vector2d<T>::set_x(const T& x){(*this)[0] = x;}

  template<typename T>
  inline
  void Vector2d<T>::u(const T& x){(*this)[0] = x;}


  template<typename T>
  inline
  void Vector2d<T>::set_x2(const T& x2){(*this)[1] = x2;}

  template<typename T>
  inline
  void Vector2d<T>::set_y(const T& y){(*this)[1] = y;}

  template<typename T>
  inline
  void Vector2d<T>::v(const T& y){(*this)[1] = y;}

  template<typename T>
  inline
  void Vector2d<T>::set(const T& x1,
                                                const T& x2)
  {
    (*this)[0] = x1;
    (*this)[1] = x2;
  }
}//slip::


namespace slip
{
template<typename T>
inline
Vector2d<T> operator+(const Vector2d<T>& V1, 
                                      const Vector2d<T>& V2)
{
  Vector2d<T> tmp;
  tmp[0] = V1[0] + V2[0];
  tmp[1] = V1[1] + V2[1];
  return tmp;
}

template<typename T>
inline
Vector2d<T> operator+(const Vector2d<T>& V1, 
                                       const T& val)
{
  Vector2d<T> tmp = V1;
  tmp+=val;
  return tmp;
}

template<typename T>
inline
Vector2d<T> operator+(const T& val,
                                       const Vector2d<T>& V1)
{
  return V1 + val;
}

template<typename T>
inline
Vector2d<T> operator-(const Vector2d<T>& V1, 
                                      const Vector2d<T>& V2)
{
  Vector2d<T> tmp;
  tmp[0] = V1[0] - V2[0];
  tmp[1] = V1[1] - V2[1];
  return tmp;
}

template<typename T>
inline
Vector2d<T> operator-(const Vector2d<T>& V1, 
                                       const T& val)
{
  Vector2d<T> tmp = V1;
  tmp-=val;
  return tmp;
}

template<typename T>
inline
Vector2d<T> operator-(const T& val,
                                       const Vector2d<T>& V1)
{
  Vector2d<T> tmp;
  tmp[0] = val - V1[0];
  tmp[1] = val - V1[1];
  return tmp;
}


template<typename T>
inline
Vector2d<T> operator*(const Vector2d<T>& V1, 
                                      const Vector2d<T>& V2)
{
  Vector2d<T> tmp;
  tmp[0] = V1[0] * V2[0];
  tmp[1] = V1[1] * V2[1];
  return tmp;
}

template<typename T>
inline
Vector2d<T> operator*(const Vector2d<T>& V1, 
                                       const T& val)
{
  Vector2d<T> tmp = V1;
  tmp*=val;
  return tmp;
}

template<typename T>
inline
Vector2d<T> operator*(const T& val,
                                       const Vector2d<T>& V1)
{
  return V1 * val;
}

template<typename T>
inline
Vector2d<T> operator/(const Vector2d<T>& V1, 
                                      const Vector2d<T>& V2)
{
  Vector2d<T> tmp;
  tmp[0] = V1[0] / V2[0];
  tmp[1] = V1[1] / V2[1];
  return tmp;
}

template<typename T>
inline
Vector2d<T> operator/(const Vector2d<T>& V1, 
                                       const T& val)
{
  Vector2d<T> tmp = V1;
  tmp/=val;
  return tmp;
}




}//slip::

namespace slip
{
  template <class _Tp>
  struct AE_rad : public std::binary_function<_Tp, slip::Vector2d<_Tp>,slip::Vector2d<_Tp> >
    {
      _Tp
      operator()(const slip::Vector2d<_Tp>& __x, const slip::Vector2d<_Tp>& __y) const
      { 
                _Tp x_norm = std::sqrt(_Tp(1) + __x[0]*__x[0] + __x[1]*__x[1]);
                _Tp y_norm = std::sqrt(_Tp(1) + __y[0]*__y[0] + __y[1]*__y[1]);
                
                return std::acos((_Tp(1) +__x[0]*__y[0] + __x[1]*__y[1]) / (x_norm * y_norm)); 
      }
    };

  template <class _Tp>
  struct AE_deg : public std::binary_function<_Tp, slip::Vector2d<_Tp>, slip::Vector2d<_Tp> >
    {
      _Tp
      operator()(const slip::Vector2d<_Tp>& __x, const slip::Vector2d<_Tp>& __y) const
      { 
                _Tp x_norm = std::sqrt(_Tp(1) + __x[0]*__x[0] + __x[1]*__x[1]);
                _Tp y_norm = std::sqrt(_Tp(1) + __y[0]*__y[0] + __y[1]*__y[1]);
                
                return (_Tp(180)/ slip::constants<_Tp>::pi())* std::acos((_Tp(1) +__x[0]*__y[0] + __x[1]*__y[1]) / (x_norm * y_norm)); 
      }
    };

  template<typename _Tp>
  inline
  std::string 
  Vector2d<_Tp>::name() const {return "Vector2d";} 
 


}//slip::

#endif //SLIP_VECTOR2D_HPP