EulerAngle.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Damien Andre       IRCER/UNILIM, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jean-luc Charles   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jean-luc.charles@ensam.eu>
//                - Jeremie Girardot   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert      LAMIH/UPHF, Valenciennes France
//                  <cedric.hubert@uphf.fr>
//                - Ivan Iordanoff     Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2019 D. Andre, JL. Charles, J. Girardot, C. Hubert, I. Iordanoff
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
#ifndef _GranOO_libGeom_EulerAngle_hpp_
#define _GranOO_libGeom_EulerAngle_hpp_
 
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include "GranOO3/3rdParty/Eigen/Dense"
 
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
 
#include "GranOO3/Geom/Constant.hpp"
#include "GranOO3/Geom/Axis.hpp"
#include "GranOO3/Core/Macro.hpp"
 
class TiXmlElement;
 
namespace GranOO3
{
  namespace Geom
  {
    class EulerAngle;
    class Quaternion;
 
    bool operator==(const EulerAngle &, const EulerAngle &);
    bool operator!=(const EulerAngle &, const EulerAngle &);
    std::ostream& operator<<(std::ostream &, const EulerAngle &);
 
 
    class EulerAngle
    {
 
    public:
      static const int N = 3;
 
    public:
      EulerAngle();
      EulerAngle(const EulerAngle &);
      explicit EulerAngle(double, double, double);
      ~EulerAngle();
 
      // Internal operators
      EulerAngle & operator=(const EulerAngle &);
 
      // Quaternion conversion
      void to_quaternion(Quaternion&) const;
      Quaternion to_quaternion() const;
      EulerAngle & operator=(const Quaternion &);
      
 
      // Component
      double & x();
      const double & x() const;
      double & y();
      const double & y() const;
      double & z();
      const double & z() const;
 
      // Component (for python wrapper)
      void set_x(const double&);
      void set_y(const double&);
      void set_z(const double&);
 
      // Component (for python wrapper)
      double get_x() const;
      double get_y() const;
      double get_z() const;
 
      template <typename Axis> double& val();
      template <typename Axis> const double& val() const;
      const double & operator() (unsigned int i) const;
      double& operator() (unsigned int i);
 
      // Misc
      bool is_nan() const;
      std::string info() const;
      void add_glob(const std::string& id);
 
    private:
      // - BOOST SERIALIZATION - //
      friend class boost::serialization::access;
      template<class Archive> void serialize(Archive&, const unsigned int );
 
    public:
      Eigen::Matrix<double, 3, 1> coord;
    };
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
 
 
    // - BOOST SERIALIZATION - //
    template<class Archive>
    void
    EulerAngle::serialize(Archive & ar, const unsigned int ) {
      ar & x(); ar & y(); ar & z();
    }
 
    // Constructors ...
    inline
    EulerAngle::EulerAngle()
      : coord() {
    }
 
    inline
    EulerAngle::EulerAngle(const EulerAngle &p)
      : coord(p.coord) {
    }
 
    inline
    EulerAngle::EulerAngle(double x, double y, double z)
      :  coord(x, y, z){
    }
 
 
    inline
    EulerAngle::~EulerAngle() {
    }
 
 
    // External Operators ...
    inline
    bool operator==(const EulerAngle & pt1, const EulerAngle & pt2) {
      return (pt1.x() == pt2.x() && pt1.y() == pt2.y() && pt1.z() == pt2.z());
    }
 
    inline
    bool operator!=(const EulerAngle & pt1, const EulerAngle & pt2) {
      return !(pt1==pt2);
    }
 
    inline double&
    EulerAngle::x() {
      return coord(0);
    }
 
    inline const double&
    EulerAngle::x() const {
      return coord(0);
    }
 
    inline double&
    EulerAngle::y() {
      return coord(1);
    }
 
    inline const double&
    EulerAngle::y() const {
      return coord(1);
    }
 
    inline double&
    EulerAngle::z() {
      return coord(2);
    }
 
    inline const double&
    EulerAngle::z() const {
      return coord(2);
    }
 
    inline void
    EulerAngle::set_x(const double& val) {
      x() = val;
    }
 
    inline void
    EulerAngle::set_y(const double& val) {
      y() = val;
    }
 
    inline void
    EulerAngle::set_z(const double& val) {
      z() = val;
    }
 
    inline double
    EulerAngle::get_x() const {
      return x();
    }
 
    inline double
    EulerAngle::get_y() const {
      return y();
    }
 
    inline double
    EulerAngle::get_z() const {
      return z();
    }
 
    template<typename Axis> inline
    double& EulerAngle::val() {
      SafeModeAssert(0, "Non specilized method is forbidden");
      return x();
    }
 
    template<typename Axis> inline
    const double& EulerAngle::val() const {
      SafeModeAssert(0, "Non specilized method is forbidden");
      return x();
    }
 
    template<> inline
    double& EulerAngle::val<X>() {
      return x();
    }
 
    template<> inline
    const double& EulerAngle::val<X>() const {
      return x();
    }
 
    template<> inline
    double& EulerAngle::val<Y>() {
      return y();
    }
 
    template<> inline
    const double& EulerAngle::val<Y>() const {
      return y();
    }
 
    template<> inline
    double& EulerAngle::val<Z>() {
      return z();
    }
 
    template<> inline
    const double& EulerAngle::val<Z>() const {
      return z();
    }
 
    inline const double&
    EulerAngle::operator() (unsigned int i) const {
      SafeModeAssert(i < 3, "The component must be in [0, 2] range");
      return coord(i);
    }
 
    inline double&
    EulerAngle::operator() (unsigned int i) {
      SafeModeAssert(i < 3, "The component must be in [0, 2] range");
      return coord(i);
    }
 
    inline std::ostream &
    operator<<(std::ostream& out, const EulerAngle& pt) {
      return out <<  pt.x() << "\t" << pt.y() << "\t"  << pt.z() <<"\t";
    }
 
    inline EulerAngle &
    EulerAngle::operator=(const EulerAngle & p) {
      if (this == &p)
        return *this;
      coord = p.coord;
      return *this;
    }
 
    inline bool
    EulerAngle::is_nan() const {
      if (x()!=x())
        return true;
      if (y()!=y())
        return true;
      if (z()!=z())
        return true;
      return false;
    }
 
 
#endif
  } // namespace Geom
}
 
#endif