PolyhedronCore.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 PolyhedronCore_hpp
#define PolyhedronCore_hpp
 
#include <vector> // std::vector
 
#include "GranOO3/Algo/StaticAABBTree.hpp"
 
class vtkUnstructuredGrid;
 
class PolyhedronCore {
 
public:
  typedef std::pair<unsigned int, unsigned int> VertexPrimitivePair;
 
public:
  PolyhedronCore();
 
  PolyhedronCore(std::string filePath);
 
  PolyhedronCore(std::stringstream &stringStream);
 
  ~PolyhedronCore();
 
public:
  void read_off_file(std::string filePath);
 
  void read_off_file(std::stringstream &stringStream);
 
  void to_off_format(std::stringstream &offString, bool basefacet = true) const;
 
  void to_vtk_ugrid(vtkUnstructuredGrid &uGrid);
 
  void clear();
 
  void clear_metric();
 
  void build_data_structure();
 
  void compute_metric();
 
  void build_aabb_tree();
 
  inline unsigned int vertex_number() const {
    return (unsigned int)_vertices.size()/3;
  };
 
 
  inline std::vector<double>& get_hitPoint() {
    return _hitPoints;
  };
 
 
  inline unsigned int basefacet_number() const {
    return (unsigned int)_basefacetToVertexOffset.size();
  };
 
  inline unsigned int facet_number() const {
    return (unsigned int)_facetToVertex.size()/3;
  };
 
  inline unsigned int edge_number() const {
    return (unsigned int)_edgeToFacet.size()/3;
  };
 
  inline bool is_watertight() const {
    return _isWatertight;
  };
 
  inline const double *min_corner_ptr() const {
    return _minCorner;
  };
 
  inline const double *max_corner_ptr() const {
    return _maxCorner;
  };
 
  inline bool is_convex() const {
    return _isConvex;
  };
 
  inline double volume() const {
    return _volume;
  };
 
  inline const double *initial_centroid_ptr() const {
    return _initialCentroid;
  };
 
  inline const double *centroid_ptr() const {
    return _centroid;
  };
 
  inline void inertia_tensor(double (&tensor)[3][3]) const {
 
    for (unsigned int ii = 0; ii < 3; ii++)
      for (unsigned int jj = 0; jj < 3; jj++)
        tensor[ii][jj] = _iMatrix[ii][jj];
  };
 
  inline unsigned int vertex_number_of_basefacet(int basefacetIndex) const {
    return _verticesPerBaseFacet[basefacetIndex];
  };
 
  inline const unsigned int vertex_index_of_basefacet(int basefacetIndex, int vertexIndex) const {
    return _basefacetToVertex[_basefacetToVertexOffset[basefacetIndex]+vertexIndex];
  };
 
  inline const unsigned int vertex_index_of_facet(int facetIndex, int vertexIndex) const {
    return _facetToVertex[3*facetIndex+vertexIndex];
  };
 
  inline const double *vertex_ptr_of_facet(unsigned int facetIndex, unsigned int vectorIndex) const {
    return &(_facetsVectors[6*facetIndex+3*vectorIndex]);
  };
 
  inline const double *normal_ptr_of_facet(int facetIndex) const {
    return &(_facetsNormals[3*facetIndex]);
  };
 
  inline const double *vertex_ptr(int vertexIndex) const {
    return &(_vertices[3*vertexIndex]);
  };
 
//  inline double *vertex_ptrRef(int vertexIndex) { return &(_vertices[3*vertexIndex]); };
 
  inline const double *normal_ptr_of_vertex(int vertexIndex) const {
    return &(_verticesNormals[3*vertexIndex]);
  };
 
  inline unsigned int basefacet_index_for_facet(unsigned int facetIndex) const {
    return _facetToBaseFacet[facetIndex];
  };
 
  double basefacet_area(unsigned int facetIndex) const;
 
  double facet_area(unsigned int facetIndex) const;
 
  void apply_offset(double offsetX, double offsetY, double offsetZ);
 
  void translate_to_centroid();
 
  void apply_scale_factor(double factor, double yFactor, double zFactor);
 
  bool contain(double aPoint[3]) const;
 
  std::vector<unsigned int> facet_hit_by_ray(Ray aRay) const;
 
  const double *closest_vertex_ptr(double aPoint[3]) const;
 
  VertexPrimitivePair closest_vertex_and_primitive(double aPoint[3]) const;
 
  void closest_point(double aPoint[3], double (&closestPoint)[3]) const;
 
  void furthest_vertex_along_axis(const double *anAxis, unsigned int &furthestVertex) const;
 
  void closest_vertex_callback(unsigned int aFacet, const double *aPoint, double &distance) const;
 
  bool raycast_aabb_tree_callback(unsigned int aFacet, Ray aRay) const;
 
  void closest_vertex_and_primitive_callback(unsigned int aFacet, const double *aPoint, double &distance) const;
 
  void closest_point_callback(unsigned int aFacet, const double *aPoint, double &distance) const;
 
  void furthest_vertex_callback(unsigned int aFacet, const double *aPoint, const double *anAxis, double &distance) const;
 
  bool is_facet_crossed_by_ray(unsigned int aFacet, Ray aRay, double (&hitPoint)[3]) const;
 
  void closest_point_in_facet(unsigned int aFacet, const double *aPoint, double (&closestPoint)[3]) const;
 
  const std::vector<unsigned int>& facet_to_vertex() const {return _facetToVertex;}
        std::vector<unsigned int>& facet_to_vertex()       {return _facetToVertex;}
 
private:
  unsigned int find_local_edge_index_of_facet(unsigned int aFacet, unsigned int anEdge);
 
  double closest_point_to_edge(const double *point0, const double *point1, const double *, double (&closestPoint)[3]) const;
 
private:
  static double SquaredDistanceErrorThreshold;
 
  static unsigned char FacetEdgeVertex[3][2];
 
  static unsigned char FacetEdgeDirection[3][3];
 
  static const unsigned int NotInList = (unsigned int)(-1);
 
private:
  std::vector<double> _vertices;
 
  std::vector<unsigned int> _basefacetToVertex;
 
  std::vector<unsigned int> _basefacetToVertexOffset;
 
  std::vector<unsigned int> _verticesPerBaseFacet;
 
  std::vector<unsigned int> _facetToVertex;
 
  std::vector<unsigned int> _basefacetToFacetOffset;
 
  std::vector<unsigned int> _facetToBaseFacet;
 
  std::vector<unsigned int> _facetToFacet;
 
  std::vector<unsigned int> _facetToEdge;
 
  std::vector<unsigned int> _edgeToVertex;
 
  std::vector<unsigned int> _edgeToFacet;
 
  std::vector<unsigned int> _nonManifoldEdges;
 
  std::vector<double> _facetsVectors;
 
  std::vector<double> _facetsNormals;
 
  std::vector<double> _verticesNormals;
 
  bool _isWatertight;
 
  double _minCorner[3];
 
  double _maxCorner[3];
 
  double _greatestSquaredDiagonal;
 
  StaticAABBTree _aabbTree;
 
  bool _isConvex;
 
  double _volume;
 
  double _initialCentroid[3];
 
  double _centroid[3];
 
  double _iMatrix[3][3];
 
private:
  mutable unsigned int _closestVertexIndex;
 
  mutable unsigned int _primitivesHitByRayCount;
 
  mutable double _closestPoint[3];
 
  mutable unsigned int _furthestVertex;
 
  mutable std::vector<double> _hitPoints;
 
  mutable std::vector<unsigned int> _hitPrimitives;
 
  mutable VertexPrimitivePair _closestVertexAndPrimitiveIndices;
 
  mutable std::vector<unsigned int> _candidateFacets;
};
 
#endif /* Polyhedron_hpp */