Point.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_Point_hpp_
#define _GranOO_libGeom_Point_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 Point;
    class Vector;
    class Frame;
 
    bool operator==(const Point &, const Point &);
    bool operator!=(const Point &, const Point &);
    std::ostream& operator<<(std::ostream &, const Point &);
 
 
    class Point
    {
 
      friend class Vector;
      friend bool operator==(const Point &, const Point &);
      friend bool operator!=(const Point &, const Point &);
      friend std::ostream& operator<<(std::ostream &, const Point &);
 
    public:
      // Usefull for internal use only, NOT DOCUMENTED !
      static Point& glob(const std::string& id);
      static std::string class_ID() {return "Point";}
      static Point* new_object(const TiXmlElement* el);
      static const int N = 3;
      
      static const Point& global;
      static const Point& null;
 
      static Point mid_point(const Point & p1, const Point & p2);
 
    public:
      // Constructors and destructor
      explicit Point();
      Point(const Point &);
      Point(const Point &, const Frame& from, const Frame& to);
      explicit Point(double, double, double);
      explicit Point(const double*);
      ~Point();
 
      // Internal operators
      Point & operator=(const Point &);
 
      // Miscellaneous Usefull methods
      Vector&        to_vector();
      const Vector & to_vector() const;
      double distance_with(const Point &) const;
      void translate(const Vector& v);
      void rotate(const Quaternion &q);
 
      // 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
    Point::serialize(Archive & ar, const unsigned int ) {
      ar & x(); ar & y(); ar & z();
    }
 
    // Constructors ...
    inline
    Point::Point()
      : coord() {
    }
 
    inline
    Point::Point(const Point &p)
      : coord(p.coord) {
    }
 
    inline
    Point::Point(double x, double y, double z)
      :  coord(x, y, z){
    }
 
    inline
    Point::Point(const double* pt)
      :  coord(pt[0], pt[1], pt[2]){
    }
 
    inline
    Point::~Point() {
    }
 
    // Accessors
    inline Vector &
    Point::to_vector() {
      return *reinterpret_cast<Vector *>(this);
    }
 
    inline const Vector &
    Point::to_vector() const {
      return *reinterpret_cast<const Vector *>(this);
    }
 
 
    // External Operators ...
    inline
    bool operator==(const Point & pt1, const Point & pt2) {
      return (pt1.x() == pt2.x() && pt1.y() == pt2.y() && pt1.z() == pt2.z());
    }
 
    inline
    bool operator!=(const Point & pt1, const Point & pt2) {
      return !(pt1==pt2);
    }
 
    inline double&
    Point::x() {
      return coord(0);
    }
 
    inline const double&
    Point::x() const {
      return coord(0);
    }
 
    inline double&
    Point::y() {
      return coord(1);
    }
 
    inline const double&
    Point::y() const {
      return coord(1);
    }
 
    inline double&
    Point::z() {
      return coord(2);
    }
 
    inline const double&
    Point::z() const {
      return coord(2);
    }
 
    inline void
    Point::set_x(const double& val) {
      x() = val;
    }
 
    inline void
    Point::set_y(const double& val) {
      y() = val;
    }
 
    inline void
    Point::set_z(const double& val) {
      z() = val;
    }
 
    inline double
    Point::get_x() const {
      return x();
    }
 
    inline double
    Point::get_y() const {
      return y();
    }
 
    inline double
    Point::get_z() const {
      return z();
    }
 
    template<typename Axis> inline
    double& Point::val() {
      SafeModeAssert(0, "Non specilized method is forbidden");
      return x();
    }
 
    template<typename Axis> inline
    const double& Point::val() const {
      SafeModeAssert(0, "Non specilized method is forbidden");
      return x();
    }
 
    template<> inline
    double& Point::val<X>() {
      return x();
    }
 
    template<> inline
    const double& Point::val<X>() const {
      return x();
    }
 
    template<> inline
    double& Point::val<Y>() {
      return y();
    }
 
    template<> inline
    const double& Point::val<Y>() const {
      return y();
    }
 
    template<> inline
    double& Point::val<Z>() {
      return z();
    }
 
    template<> inline
    const double& Point::val<Z>() const {
      return z();
    }
 
    inline const double&
    Point::operator() (unsigned int i) const {
      SafeModeAssert(i < 3, "The component must be in [0, 2] range");
      return coord(i);
    }
 
    inline double&
    Point::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 Point& pt) {
      return out <<  pt.x() << "\t" << pt.y() << "\t"  << pt.z() <<"\t";
    }
 
    inline Point &
    Point::operator=(const Point & p) {
      if (this == &p)
        return *this;
      coord = p.coord;
      return *this;
    }
 
    inline bool
    Point::is_nan() const {
      if (x()!=x())
        return true;
      if (y()!=y())
        return true;
      if (z()!=z())
        return true;
      return false;
    }
 
    // Usefull Methods
 
    inline double
    Point::distance_with(const Point & pt) const {
      return sqrt( (x()-pt.x())*(x()-pt.x())+
                   (y()-pt.y())*(y()-pt.y())+
                   (z()-pt.z())*(z()-pt.z()));
    }
 
    inline Point
    Point::mid_point(const Point & p1, const Point & p2) {
      return Point(0.5*(p1.x()+p2.x()),
                   0.5*(p1.y()+p2.y()),
                   0.5*(p1.z()+p2.z()));
    }
 
#endif
  } // namespace Geom
}
 
#endif