Volume.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_LibShape_Volume_hh_
#define _GranOO_LibShape_Volume_hh_
 
#include <iostream>
#include <string>
#include <cmath>
#include <set>
 
#include <boost/version.hpp>
 
#if BOOST_VERSION >= 107400
#include <boost/serialization/library_version_type.hpp>
#endif
 
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/set.hpp>
 
#include "GranOO3/Algo/StaticAABBTree.hpp"
#include "GranOO3/Collision/Dispatcher.hpp"
#include "GranOO3/Geom/Quaternion.hpp"
#include "GranOO3/Geom/Tensor.hpp"
#include "GranOO3/Geom/Point.hpp"
#include "GranOO3/Shape/Base.hpp"
#include "GranOO3/Core/String.hpp"
#include "GranOO3/Core/XmlParser.hpp"
#include "GranOO3/Core/XmlObjectManager.hpp"
 
// Macro the manage detection collision
// If a new volume shape class is added, these macro have to
// be addited
#define GRANOO_DECLARE_SHAPE_COLLISION()                        \
  bool collide(const Volume&, Collision::Data& c) const;        \
  bool collide(const Sphere&, Collision::Data& c) const;        \
  bool collide(const Box&, Collision::Data& c) const;           \
  bool collide(const Cylinder&, Collision::Data& c) const;      \
  bool collide(const Cone&, Collision::Data& c) const;          \
  bool collide(const ConeTruncated&, Collision::Data& c) const; \
  bool collide(const Polyhedron&, Collision::Data& c) const;
 
#define GRANOO_IMPLEMENT_SHAPE_COLLISION(CLASS)                         \
  bool CLASS::collide(const Volume&  v, Collision::Data& c) const       \
  {return v.collide(*this, c);}                                         \
  bool CLASS::collide(const Sphere& v, Collision::Data& c) const        \
  {return Collision::Dispatcher::run(*this, v, c);}                     \
  bool CLASS::collide(const Box& v, Collision::Data& c) const           \
  {return Collision::Dispatcher::run(*this, v, c);}                     \
  bool CLASS::collide(const Cylinder& v, Collision::Data& c) const      \
  {return Collision::Dispatcher::run(*this, v, c);}                     \
  bool CLASS::collide(const Cone& v, Collision::Data& c) const          \
  {return Collision::Dispatcher::run(*this, v, c);}                     \
  bool CLASS::collide(const ConeTruncated& v, Collision::Data& c) const \
  {return Collision::Dispatcher::run(*this, v, c);}                     \
  bool CLASS::collide(const Polyhedron& v, Collision::Data& c) const    \
  {return Collision::Dispatcher::run(*this, v, c);}
 
#define GRANOO_ACCESS_SHAPE_DIM(method, type, variable)                        \
  void set_ ## method (const type& val) {                                      \
    SafeModeAssert(val >= 0., "The value must be positive");                   \
    variable = val; if (is_bounding_shape()==false) update_bounding_shape(); } \
  GRANOO_ACCESS_GET (method, type, variable)\
  GRANOO_ACCESS_REF (method, type, variable)
 
 
namespace GranOO3
{
  namespace Shape
  {
 
    class Sphere; class Box; class Cylinder; class Cone; class ConeTruncated; class Polyhedron;
 
    enum Interference {INSIDE, OUTSIDE, OVERLAP};
 
    class Volume : public Base
    {
    public:
      static std::string class_ID() {return "Volume";}
 
    public:
      //CONSTRUCTORS & DESTRUCTORS
      explicit Volume(const Geom::Frame &frame);
      virtual ~Volume();
 
      //USEFULL
      virtual double get_volume() const = 0;
      virtual void compute_inertia_tensor(double density, Geom::Tensor &) const = 0;
      virtual Geom::Point farthest_point_along(const Geom::Vector& dir) const = 0;
      bool is_surface() const {return false;}
      bool is_volume()  const {return true;}
 
      //BOUNDING SHAPE
      const Box&    get_bounding_box()    const;
      const Sphere& get_bounding_sphere() const;
      Box&    get_bounding_box();
      Sphere& get_bounding_sphere();
 
      virtual double get_greatest_dimension() const = 0;
      virtual void update_bounding_box() = 0;
      virtual void update_bounding_sphere() = 0;
      void update_bounding_shape(); // It updates both bounding box and shape
      bool is_bounding_shape() const;
      virtual AABB aabb() const = 0;
 
      //CONTACT DETECTION v1
      template<Interference T>
      bool overlap(const Sphere&, Geom::Vector& normal, double& penetration) const;
      virtual Interference locate(const Geom::Point&) const = 0;
      virtual Interference locate(const Geom::Point&, double radius) const = 0;
      Interference locate(const Sphere&) const;
 
      //CONTACT DETECTION v2
      virtual bool collide_inside (const Geom::Point& p1, double radius, Collision::Data& info) const = 0; 
      virtual bool collide_outside(const Geom::Point& p1, double radius, Collision::Data& info) const = 0; 
      bool collide_inside (const Geom::Point&, Collision::Data&) const; 
      bool collide_outside(const Geom::Point&, Collision::Data&) const; 
      virtual bool collide(const Volume&, Collision::Data&) const = 0;
      virtual bool collide(const Sphere&, Collision::Data&) const = 0;
      virtual bool collide(const Box&, Collision::Data&) const = 0;
      virtual bool collide(const Cylinder&, Collision::Data&) const = 0;
      virtual bool collide(const Cone&, Collision::Data&) const = 0;
      virtual bool collide(const ConeTruncated&, Collision::Data&) const = 0;
      virtual bool collide(const Polyhedron&, Collision::Data&) const = 0;
 
      GRANOO_ACCESS_GET(bounding_radius, double, _bounding_radius);
 
      //FACE & BOUNDARY MANAGEMENT
      const std::set<std::string>& get_face_ID() const;
 
    protected:
      template<typename T, typename ... Args> void set_face_ID(const T&, Args... args);
      template<typename T> void set_face_ID(const T&);
      void copy_face_ID(const std::set<std::string>&);
      void add_face_ID(const std::string&);
 
    private:
      Volume(const Volume &);          // Copy constructor forbiden
      Volume & operator=(const Volume &); // Assignement operator forbiden
 
      //SERIALIZATION
      friend class boost::serialization::access;
      template<class Archive> void save(Archive&, const unsigned int ) const;
      template<class Archive> void load(Archive&, const unsigned int);
      BOOST_SERIALIZATION_SPLIT_MEMBER();
 
    private:
      Box*    _bounding_box;
      Sphere* _bounding_sphere;
      bool    _bounding_shape;
      double  _bounding_radius;
      std::set<std::string> _face;
 
    };
 
 
    template<typename T, typename ... Args>
    inline void
    Volume::set_face_ID(const T& key, Args... args) {
      const std::string k(key);
      AssertMsg(_face.count(k)==0, "The face " + k + " was already registered");
      _face.insert(k);
      set_face_ID(args ...);
    }
 
    template<typename T>
    inline void
    Volume::set_face_ID(const T& key) {
      const std::string k(key);
      AssertMsg(_face.count(k)==0, "The face " + k + " was already registered");
      _face.insert(k);
    }
 
    inline const std::set<std::string>&
    Volume::get_face_ID() const {
      return _face;
    }
 
    inline bool
    Volume::is_bounding_shape() const {
      return _bounding_shape;
    }
 
    inline void
    Volume::add_face_ID(const std::string& name) {
      AssertMsg(_face.count(name)==0, "The face " + name + " was already registered");
      _face.insert(name);
    }
 
    inline void
    Volume::copy_face_ID(const std::set<std::string>& set) {
      _face = set;
    }
 
 
    template<class Archive>
    inline void
    Volume::save(Archive& ar, const unsigned int) const {
      ar << boost::serialization::base_object<Shape::Base>(*this);
      ar << _face;
    }
 
    template<class Archive>
    inline void
    Volume::load(Archive& ar, const unsigned int) {
      ar >> boost::serialization::base_object<Shape::Base>(*this);
      _face.clear();
      ar >> _face;
    }
 
  } // namespace Shape
}
 
 
#endif