tessellation.h

Go to the documentation of this file.

/* Author(s):     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-06-04
 * Last modified: 2015-03-19
 *
 * License:
 *
 * Description:
 *
 * History:
 *
 */

#ifndef GEOMTOOLS_TESSELLATION_H
#define GEOMTOOLS_TESSELLATION_H 1

// Standard library:
#include <iostream>
#include <string>
#include <map>
#include <vector>

// Third party:
// - Boost:
#include <boost/cstdint.hpp>
// - Bayeux/mygsl:
#include <mygsl/min_max.h>

// This project:
#include <geomtools/i_shape_2d.h>
#include <geomtools/i_shape_3d.h>

namespace geomtools {

  // Forward declarations:
  class facet34;
  class box;
  class triangle;
  class quadrangle;

  struct facet_vertex
  {

  public:

    bool is_valid() const;

    facet_vertex();

    facet_vertex(double x_, double y_, double z_);

    void print_xyz(std::ostream & out_, int color_ = 0) const;

    void print(std::ostream & out_) const;

    void add_ref_facet(int facet_index_, int facet_node_);

    const vector_3d & get_position() const;

    void set_position(const vector_3d &);

    vector_3d & grab_position();

    void reset();

    friend std::ostream & operator<<(std::ostream &, const facet_vertex &);

  public:

    vector_3d position; 
    std::map<int32_t, int32_t> ref_facets; 

  };

  class facet34
  {

  public:

    static const unsigned int MAX_CATEGORY = 30;
    static const int32_t INVALID_CATEGORY = -1;

    bool has_category() const;

    void set_category(unsigned int c_);

    void unset_category();

    uint32_t get_number_of_vertices() const;

    const facet_vertex & get_vertex(int i_) const;

    int32_t get_vertex_key(int i_) const;

    bool has_normal() const;

    bool has_surface() const;

    bool is_valid() const;

    const vector_3d & get_normal() const;

    double get_surface() const;

    double get_internal_angle(int i_) const;

    void print(std::ostream & out_) const;

    static bool check_triangle(const geomtools::vector_3d & v0_,
                               const geomtools::vector_3d & v1_,
                               const geomtools::vector_3d & v2_,
                               double tolerance_ = 0.0);

    static bool check_quadrangle(const geomtools::vector_3d & v0_,
                                 const geomtools::vector_3d & v1_,
                                 const geomtools::vector_3d & v2_,
                                 const geomtools::vector_3d & v3_,
                                 double tolerance_ = 0.0);

    bool is_triangle() const;

    bool is_quadrangle() const;

    void set_triangle(const facet_vertex & v0_,
                      const facet_vertex & v1_,
                      const facet_vertex & v2_,
                      int iv0_,
                      int iv1_,
                      int iv2_);

    void set_quadrangle(const facet_vertex & v0_,
                        const facet_vertex & v1_,
                        const facet_vertex & v2_,
                        const facet_vertex & v3_,
                        int iv0_,
                        int iv1_,
                        int iv2_,
                        int iv3_);

    facet34();

    facet34(const facet_vertex & v0_,
            const facet_vertex & v1_,
            const facet_vertex & v2_,
            int, int, int);

    facet34(const facet_vertex & v0_,
            const facet_vertex & v1_,
            const facet_vertex & v2_,
            const facet_vertex & v3_,
            int, int, int, int);

    bool has_face() const;

    bool has_tface() const;

    bool has_qface() const;

    const triangle & get_tface() const;

    const quadrangle & get_qface() const;

    const face_handle_type & get_tface_handle() const;

    face_handle_type & grab_tface_handle();

    const face_handle_type & get_qface_handle() const;

    face_handle_type & grab_qface_handle();

  protected:

    void _set_defaults();

    void _compute_normal();

    void _compute_surface();

    void _compute_internal_angles(); // Not implemented yet

    void _compute_face();

    void _compute_internals();

  private:

    // Primary data:
    uint32_t             _number_of_vertices_; 
    const facet_vertex * _vertices_[4];        
    int32_t              _vertices_keys_[4];   

    // Working data:
    geomtools::vector_3d _normal_;             
    double               _surface_;            
    double               _internal_angles_[4]; 
    int32_t              _category_;           
    face_handle_type     _tface_;
    face_handle_type     _qface_;

  };

  class facet_segment
  {
  public :

    enum vertex_id_type {
      VTX_ID_NONE   = -1,
      VTX_ID_FIRST  = 0,
      VTX_ID_SECOND = 1
    };

    bool is_valid() const;

    bool is_shown() const;

    void set_shown(bool);

    facet_segment();

    void set_vertex_keys(int, int);

    void set_vertexes(const facet_vertex & vtx0_, const facet_vertex & vtx1_);

    bool has_vertex(vertex_id_type) const;

    const vector_3d & get_vertex_position(vertex_id_type) const;

    void set_facet_keys(int, int);

    void set(int, int, int, int);

    friend bool operator==(const facet_segment & fs1_, const facet_segment & fs2_);

    friend bool operator<(const facet_segment & fs1_, const facet_segment & fs2_);

    void dump(std::ostream & out_) const;

  public :

    int vertex0_key; 
    int vertex1_key; 
    int facet0_key;  
    int facet1_key;  

  private:

    bool _shown_;      
    const facet_vertex * _vertex0_; 
    const facet_vertex * _vertex1_; 

  };

  class tessellated_solid : public i_shape_3d,
                            public i_stackable
  {
  public:

    static const int INVALID_VERTEX      = -1;
    static const int MAX_VERTEX          = 0x0FFFFFFF;
    static const unsigned int INVALID_FACET_INDEX = 0xFFFFFFFF;

    static const std::string & tessellated_label();

    typedef std::map<unsigned int, facet_vertex>  vertices_col_type;
    typedef std::map<unsigned int, facet34>       facets_col_type;
    typedef std::map<unsigned int, facet_segment> facet_segments_col_type;

    virtual std::string get_shape_name() const;

    static bool validate_index(int);

    bool is_consistent() const;

    bool using_face_id_bits() const;

    bool using_face_id_index() const;

    tessellated_solid();

    virtual ~tessellated_solid();

    const vertices_col_type & vertices() const;

    const facets_col_type & facets() const;

    const facet_segments_col_type & facet_segments() const;

    vertices_col_type & grab_vertices();

    facets_col_type & grab_facets();

    facet_segments_col_type & grab_facet_segments();

    int add_vertex(unsigned int vtx_key_, const facet_vertex & vtx_);

    int add_vertex(unsigned int vtx_key_,
                   double x_, double y_, double z_);

    void add_facet(unsigned int facet_key_,
                   int ivtx0_, int ivtx1_, int ivtx2_, int ivtx3_ = INVALID_VERTEX);

    void add_facet3(unsigned int facet_key_,
                    int ivtx0_, int ivtx1_, int ivtx2_);

    void add_facet4(unsigned int facet_key_,
                    int ivtx0_, int ivtx1_, int ivtx2_, int ivtx3_);

    void remove_facet(unsigned int facet_key_);

    bool has_facet(unsigned int facet_key_) const;

    const facet34 & get_facet(unsigned int facet_key_) const;

    void compute_bounding_box();

    const mygsl::min_max & get_bounding_box_x() const;

    const mygsl::min_max & get_bounding_box_y() const;

    const mygsl::min_max & get_bounding_box_z() const;

    double get_xmin() const;

    double get_xmax() const;

    double get_ymin() const;

    double get_ymax() const;

    double get_zmin() const;

    double get_zmax() const;

    void print_xyz(std::ostream & out_) const;

    void dump(std::ostream & out_ = std::clog) const;

    virtual bool is_inside (const vector_3d &,
                            double skin_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual bool is_outside (const vector_3d &,
                             double skin_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual face_identifier on_surface(const vector_3d &,
                                       const face_identifier & a_surface_mask = face_identifier::FACE_INDEX_ANY,
                                       double a_skin = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual vector_3d get_normal_on_surface (const vector_3d & position_,
                                             const face_identifier & ) const;

    virtual bool find_intercept(const vector_3d & from_,
                                const vector_3d & direction_,
                                face_intercept_info & intercept_,
                                double skin_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual unsigned int compute_faces(face_info_collection_type &) const;

    enum tessella_wires_rendering_option_type {
      WR_TESSELLA_ALL_SEGMENTS   = (WR_BASE_LAST << 1),        
      WR_TESSELLA_LAST           = (WR_TESSELLA_ALL_SEGMENTS), 
      WR_TESSELLA_MASK           = (WR_TESSELLA_ALL_SEGMENTS
                                    )
    };

    virtual void generate_wires_self(wires_type & wires_,
                                     uint32_t options_ = 0) const;


    virtual void initialize(const datatools::properties &, const handle_dict_type * = 0);

    virtual void reset();

    void initialize_from_stl(const std::string & filename_,
                             double length_unit_);

    bool is_valid() const;

    virtual void tree_dump(std::ostream & a_out         = std::clog,
                           const std::string & a_title  = "",
                           const std::string & a_indent = "",
                           bool a_inherit          = false) const;

  protected:

    virtual void _at_lock();

    virtual void _at_unlock();

    virtual void _build_bounding_data();

    void _compute_facet_segments();

    bool _on_facet(const vector_3d & position_, unsigned int & facet_index_, double skin_) const;

    bool _find_intercept_exclude(const vector_3d & from_,
                                 const vector_3d & direction_,
                                 face_intercept_info & intercept_,
                                 double skin_,
                                 const std::set<unsigned int> & excluded_facet_indexes_) const;

    unsigned int _find_intercepts_exclude(const vector_3d & from_,
                                          const vector_3d & direction_,
                                          std::vector<face_intercept_info> & intercepts_,
                                          double skin_,
                                          const std::set<unsigned int> & excluded_facet_indexes_) const;

  private:

    bool _check_();

  private:

    bool              _consistent_; 
    vertices_col_type _vertices_;   
    facets_col_type   _facets_; 
    mygsl::min_max    _xrange_; 
    mygsl::min_max    _yrange_; 
    mygsl::min_max    _zrange_; 
    facet_segments_col_type _facet_segments_; 

    // Registration interface :
    GEOMTOOLS_OBJECT_3D_REGISTRATION_INTERFACE(tessellated_solid)

  };

} // end of namespace geomtools

#endif // GEOMTOOLS_TESSELLATION_H

/*
** Local Variables: --
** mode: c++ --
** c-file-style: "gnu" --
** tab-width: 2 --
** End: --
*/